├── LICENSE
├── README.md
├── docs-r2.1
└── ru
│ ├── REVIEWERS
│ ├── guide
│ ├── _index.yaml
│ ├── effective_tf2.md
│ └── migrate.ipynb
│ ├── r1
│ ├── README.md
│ ├── guide
│ │ ├── eager.ipynb
│ │ ├── effective_tf2.md
│ │ ├── estimators.md
│ │ ├── keras.ipynb
│ │ └── tensors.md
│ └── tutorials
│ │ └── keras
│ │ ├── README.md
│ │ ├── basic_classification.ipynb
│ │ ├── basic_regression.ipynb
│ │ ├── basic_text_classification.ipynb
│ │ ├── overfit_and_underfit.ipynb
│ │ └── save_and_restore_models.ipynb
│ └── tutorials
│ ├── keras
│ ├── classification.ipynb
│ ├── overfit_and_underfit.ipynb
│ ├── regression.ipynb
│ ├── save_and_load.ipynb
│ └── text_classification_with_hub.ipynb
│ ├── load_data
│ ├── csv.ipynb
│ ├── images.ipynb
│ ├── numpy.ipynb
│ ├── pandas_dataframe.ipynb
│ ├── text.ipynb
│ ├── tfrecord.ipynb
│ └── unicode.ipynb
│ ├── quickstart
│ ├── advanced.ipynb
│ └── beginner.ipynb
│ └── structured_data
│ └── feature_columns.ipynb
└── site
├── en
└── tutorials
│ └── keras
│ └── basic-regression.ipynb
└── ru
└── tutorials
├── images
└── pix2pix.ipynb
└── keras
└── basic_regression.ipynb
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2018 Andrew Stepin
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Неофициальный перевод
2 |
3 | Вся информация в этом разделе переведена с помощью русскоговорящего Tensorflow
4 | сообщества на общественных началах. Поскольку этот перевод не является
5 | официальным, мы не гарантируем что он на 100% аккуратен и соответствует
6 | [официальной документации на английском языке](https://www.tensorflow.org/?hl=en).
7 | Если у вас есть предложение как исправить этот перевод, мы будем очень рады
8 | увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs)
9 | репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow
10 | лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим),
11 | напишите нам на
12 | [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru).
13 |
14 | # Community translations
15 |
16 | Our TensorFlow community has translated these documents. Because community
17 | translations are *best-effort*, there is no guarantee that this is an accurate
18 | and up-to-date reflection of the
19 | [official English documentation](https://www.tensorflow.org/?hl=en).
20 | If you have suggestions to improve this translation, please send a pull request
21 | to the [tensorflow/docs](https://github.com/tensorflow/docs) GitHub repository.
22 | To volunteer to write or review community translations, contact the
23 | [docs@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs).
24 |
25 | Note: Please focus translation efforts on
26 | [TensorFlow 2](https://www.tensorflow.org) in the
27 | [site/en/r2](https://github.com/tensorflow/docs/tree/master/site/en/r2)
28 | directory. TF 1.x community docs will no longer be updated as we prepare for the
29 | 2.0 release. See
30 | [the announcement](https://groups.google.com/a/tensorflow.org/d/msg/docs/vO0gQnEXcSM/YK_ybv7tBQAJ).
31 |
32 | # Как добавить свой перевод?
33 |
34 | 1. Ознакомьтесь с [уже имеющейся документацией на русском языке](https://github.com/tensorflow/docs/tree/master/site/ru)
35 | 2. Внесите правки в уже готовый перевод или [выберите еще не переведенный в папке site/en/](https://github.com/tensorflow/docs/tree/master/site/en)
36 | 3. Переводите на русский язык блоки основные текста документации, а также поясняющие комментарии в коде
37 |
38 | Обратите внимание: документы, которые начинаются с символа нижнего подчеркивания (например, `_style_transfer.ipynb`) все еще находятся в процессе работы и пока не импортируются на [tensorflow.org](https://www.tensorflow.org/)
39 |
40 | Смотрите хороший пример переведенного нами [урока по TensorFlow Keras API здесь](https://github.com/tensorflow/docs/blob/master/site/ru/tutorials/keras/basic_classification.ipynb).
41 |
42 | # Советы
43 |
44 | 1. Не стесняйтесь добавлять не полностью переведенные документации: таким образом другие участники смогут увидеть ваш Pull Request и помочь если требуется
45 | 2. Вы также можете [создать черновик (Draft)](https://help.github.com/en/articles/about-pull-requests#draft-pull-requests) для будущего Pull Request. Таким образом вы сможете добавлять изменения, не уведомляя владельца репозитария: это удобно для работы над крупными текстами
46 | 3. Используйте комментарии TODO или IMPROVE в тексте и коде в тех местах, где можно объяснить код или операцию более понятным языком, но вы пока не знаете как (это позволит другим переводчикам помочь вам с толкованием)
47 | 4. Проверьте основные моменты [Google Developer Documentation Style Guide](https://developers.google.com/style/highlights): это поможет вам с переводом и проверкой технической документации и уроков
48 |
49 | # Russian translation guide
50 |
51 | Some technical words in English do not have a natural translation. Do *not*
52 | translate the following words:
53 |
54 | * (mini-) batch
55 | * estimator
56 | * eager execution
57 | * dense
58 | * dropout
59 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/REVIEWERS:
--------------------------------------------------------------------------------
1 | # Add your GitHub username to get comment-tagged on all pull requests to
2 | # the site/ru directory. Remove your username whenever you'd like.
3 | #
4 | # New pull request notifications are also sent to the
5 | # docs-ru@tensorflow.org list:
6 | # https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru
7 | #
8 | 0101011
9 | stabuev
10 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/guide/_index.yaml:
--------------------------------------------------------------------------------
1 | book_path: /overview/_book.yaml
2 | project_path: /overview/_project.yaml
3 | description:
4 | landing_page:
5 | custom_css_path: /site-assets/css/style.css
6 | nav: left
7 | rows:
8 | - classname:
9 | devsite-landing-row-100
10 | devsite-landing-row-large-headings
11 | items:
12 | - description: >
13 |
14 | TensorFlow 2 фокусируется на простоте и удобстве использования, с такими обновлениями,
15 | как eager execution, интуитивно понятные высокоуровневые API и гибкое построение
16 | моделей на любой платформе.
17 |
18 |
19 | Многие руководства написаны в виде ноутбуков Jupyter и запускаются непосредственно
20 | в Google Colab - среде для ноутбуков, которая не требует установки.
21 | Используйте в руководствах кнопку «Запустить в Google Colab».
22 |
23 |
24 | - heading: Необходимая документация
25 | classname: tfo-landing-page-heading
26 | items:
27 | - classname: tfo-landing-page-card
28 | description: >
29 | Установка TensorFlow
30 | Установите пакет или соберите из исходников.
31 | Поддержка GPU для карт с поддержкой CUDA®.
32 | path: /install
33 | - classname: tfo-landing-page-card
34 | description: >
35 | TensorFlow 2
36 | Лучшие практики и инструменты TensorFlow 2 для переноса вашего кода.
37 | path: /guide/effective_tf2
38 | - classname: tfo-landing-page-card
39 | description: >
40 | Keras
41 | Keras это более легкий для ML новичков высокоуровневый API
42 | подходящий и для исследователей.
43 | path: /guide/keras/overview
44 |
45 | - items:
46 | - classname: tfo-landing-page-card
47 | description: >
48 | Настройка
49 | TensorFlow для исследований и экспериментов. Напишите пользовательские слои и модели, прямой проход и обучающие циклы.
50 | path: /guide/eager
51 | - classname: tfo-landing-page-card
52 | description: >
53 | Конвейеры ввода данных
54 | API tf.data позволяют вам построить сложные конвейеры ввода
55 | данных из простых переиспользуемых частей.
56 | path: /guide/data
57 | - classname: tfo-landing-page-card
58 | description: >
59 | Оценщики
60 | Высокоуровневый API, представляющий законченную модель, спроектирован
61 | для масштабирования и асинхронного обучения.
62 | path: /guide/estimator
63 |
64 | - items:
65 | - classname: tfo-landing-page-card
66 | description: >
67 | Соханение модели
68 | Сохраняйте модели TensorFlow используя контрольные точки или формат SavedModel.
69 | path: /guide/checkpoint
70 | - classname: tfo-landing-page-card
71 | description: >
72 | Акселераторы
73 | Распределите обучение между несколькими GPU, компьютерами или TPU.
74 | path: /guide/distributed_training
75 |
76 | - classname: devsite-landing-row-100
77 | items:
78 | - description: >
79 | Библиотеки и расширения
80 | Изучите дополнительные ресурсы для создания сложных
81 | моделей или методов с использованием TensorFlow, получения доступа к специализированным
82 | пакетам приложений, расширяющих функционал TensorFlow.
83 |
84 | - classname: devsite-landing-row-100
85 | items:
86 | - list:
87 | - description: >
88 | TensorBoard
89 | Набор инструментов визуализации для понимания, отладки и оптимизации
90 | программ TensorFlow.
91 | path: /tensorboard
92 | icon:
93 | icon_name: chevron_right
94 | foreground: theme
95 | background: grey
96 | - description: >
97 | TensorFlow Hub
98 | Библиотека для публикации, изучения и использования переиспользуемых
99 | частей моделей машинного обучения.
100 | path: /hub
101 | icon:
102 | icon_name: chevron_right
103 | foreground: theme
104 | background: grey
105 | - description: >
106 | Model Optimization
107 | TensorFlow Model Optimization Toolkit представляет собой набор инструментов
108 | оптимизации моделей ML для использования в продакшне.
109 | path: /model_optimization
110 | icon:
111 | icon_name: chevron_right
112 | foreground: theme
113 | background: grey
114 | - description: >
115 | TensorFlow Federated
116 | Фреймворк для машинного обучения и других вычислений на децентрализованных
117 | данных.
118 | path: /federated
119 | icon:
120 | icon_name: chevron_right
121 | foreground: theme
122 | background: grey
123 | - description: >
124 | Нейронное структурированное обучение
125 | Учебная парадигма для обучения нейронных сетей путем использования структурированных
126 | сигналов в дополнение к входным параметрам.
127 | path: /neural_structured_learning
128 | icon:
129 | icon_name: chevron_right
130 | foreground: theme
131 | background: grey
132 | - description: >
133 | TensorFlow Graphics
134 | Библиотека функций компьютерной графики, начиная от камер, источников света и материалов до рендеров.
135 | path: /graphics
136 | icon:
137 | icon_name: chevron_right
138 | foreground: theme
139 | background: grey
140 | - list:
141 | - description: >
142 | Датасеты
143 | Коллекция датасетов готовых к использованию с TensorFlow.
144 | path: /datasets
145 | icon:
146 | icon_name: chevron_right
147 | foreground: theme
148 | background: grey
149 | - description: >
150 | Serving
151 | Система обслуживания TFX для моделей машинного обучения, предназначенная для достижения высокой
152 | производительности в продакшене.
153 | path: /tfx/guide/serving
154 | icon:
155 | icon_name: chevron_right
156 | foreground: theme
157 | background: grey
158 | - description: >
159 | Probability
160 | TensorFlow Probability это библиотека для вероятностных рассуждений и
161 | статистического анализа.
162 | path: /probability
163 | icon:
164 | icon_name: chevron_right
165 | foreground: theme
166 | background: grey
167 | - description: >
168 | MLIR
169 | MLIR унифицирует инфраструктуру для высокопроизводительных моделей ML в
170 | TensorFlow.
171 | path: /mlir
172 | icon:
173 | icon_name: chevron_right
174 | foreground: theme
175 | background: grey
176 | - description: >
177 | XLA
178 | Компилятор линейной алгебры для различных областей применения, ускоряющий
179 | модели TensorFlow потенциально без изменений исходного кода.
180 | path: /xla
181 | icon:
182 | icon_name: chevron_right
183 | foreground: theme
184 | background: grey
185 | - description: >
186 | SIG Addons
187 | Дополнительная функциональность для TensorFlow, поддерживаемая SIG Addons.
188 | path: https://github.com/tensorflow/addons
189 | icon:
190 | icon_name: chevron_right
191 | foreground: theme
192 | background: grey
193 | - description: >
194 | SIG IO
195 | Расширения баз данных, потоковых передач и файловых систем поддерживаемых SIG IO.
196 | path: https://github.com/tensorflow/io
197 | icon:
198 | icon_name: chevron_right
199 | foreground: theme
200 | background: grey
201 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/guide/effective_tf2.md:
--------------------------------------------------------------------------------
1 | # Эффективный TensorFlow 2.0
2 |
3 | В TensorFlow 2.0 сделан ряд изменений делающих пользователей TensorFlow более
4 | продуктивными. TensorFlow 2.0 удалил
5 | [избыточные API](https://github.com/tensorflow/community/blob/master/rfcs/20180827-api-names.md),
6 | после чего API стали более согласованными
7 | ([Unified RNNs](https://github.com/tensorflow/community/blob/master/rfcs/20180920-unify-rnn-interface.md),
8 | [Unified Optimizers](https://github.com/tensorflow/community/blob/master/rfcs/20181016-optimizer-unification.md)),
9 | и лучше интегрировался с Python runtime, с
10 | [Eager execution](https://www.tensorflow.org/guide/eager).
11 |
12 | Многие
13 | [RFCs](https://github.com/tensorflow/community/pulls?utf8=%E2%9C%93&q=is%3Apr)
14 | объяснили изменения которые вошли в TensorFlow 2.0. Это руководство
15 | представляет взгляд на кто как должна выглядеть разработка в TensorFlow 2.0.
16 | Предполагается, что вы знакомы с TensorFlow 1.x.
17 |
18 | ## Короткая выдержка основных изменений
19 |
20 | ### Очистка API
21 |
22 | Много API либо
23 | [удалены либо перемещены](https://github.com/tensorflow/community/blob/master/rfcs/20180827-api-names.md)
24 | в TF 2.0. Некоторые из основных изменений включают удаление `tf.app`,
25 | `tf.flags`, и `tf.logging` в пользу
26 | [absl-py](https://github.com/abseil/abseil-py) который сейчас с открытым
27 | исходным кодом, перенос проектов которые находились в `tf.contrib`, и очистки
28 | основного пространства имен `tf.*` путем перемещения редко используемых функций
29 | в подпакеты наподобие `tf.math`. Неокторые API были замещены своими
30 | эквивалентами 2.0 - `tf.summary`, `tf.keras.metrics`, и `tf.keras.optimizers`.
31 | Наиболее простым способом автоматически применить эти переименования является
32 | использование [скрипта обновления v2](upgrade.md).
33 |
34 | ### Eager execution
35 |
36 | В TensorFlow 1.X от пользователей требовалось вручную собирать
37 | [абстрактное синтаксическое дерево](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE)
38 | (граф) выполняя `tf.*` API запросы. Затем пользователи должны вручную
39 | скомпилировать абстрактное синтаксическое дерево путем передачи множества
40 | выходных и входных тензоров в вызов `session.run()`. TensorFlow 2.0 выполняется
41 | сразу же (как это обычно делает Python) и в 2.0, графы и сессии должны
42 | рассматриваться как детали реализации.
43 |
44 | Одним заметным побочным продуктом eager execution является то, что
45 | `tf.control_dependencies()` более не требуется, так как все строки кода
46 | выполняются по очереди (в пределах `tf.function`, код с побочными эффектами
47 | выполняется в том порядке в котором он написан).
48 |
49 | ### Нет больше глобалов
50 |
51 | TensorFlow 1.X значительно зависел от неявных глобальных пространств имен. Когда
52 | вы вызывали `tf.Variable()`, она помещалась в граф по умолчанию, и она
53 | оставалась там даже если вы потеряли track переменной Python указывавшей на
54 | него. Вы можете затем восстановить ту `tf.Variable`, но только если вы знали имя
55 | с которым она была создана. Это было сложно сделать если вы не контролировали
56 | создание переменных. В результате этого, размножались все виды механизмов
57 | пытавшиеся помочь пользователям снова найти их переменные, а для фреймворков -
58 | найти созданные пользователями переменные: Области переменных, глобальные
59 | коллекции, методы помощники такие как `tf.get_global_step()`,
60 | `tf.global_variables_initializer()`, оптимизаторы неявно вычисляющие градиенты
61 | по всем обучаемым переменным, и т.д. TensorFlow 2.0 устраняет все эти механизмы
62 | ([Variables 2.0 RFC](https://github.com/tensorflow/community/pull/11)) в пользу
63 | механизма по умолчанию: Отслеживайте свои переменные! Если вы потеряли след
64 | `tf.Variable`, он будет очищен сборщиком мусора.
65 |
66 | Требование отслеживать мусор создает дополнительную работу для пользователя,
67 | но с объектами Keras (см. ниже), нагрузка минимизирована.
68 |
69 | ### Функции, не сессии
70 |
71 | Вызов `session.run()` почти похож на вызов функции: Вы определяете вводные
72 | данные, функция вызывается и вы получаете набор результатов. В TensorFlow 2.0,
73 | вы можете декорировать функцию Python используя `tf.function()` чтобы отметить
74 | ее для JIT компиляции так что TensorFlow выполняет его как единый граф
75 | ([Functions 2.0 RFC](https://github.com/tensorflow/community/pull/20)). Этот
76 | механизм позволяет TensorFlow 2.0 получить все преимущества режима графа:
77 |
78 | - Производительность: функция может быть оптимизирована (node pruning, kernel
79 | fusion, etc.)
80 | - Портативность: функция может быть экспортирована / реимпортирована
81 | ([RFC SavedModel 2.0](https://github.com/tensorflow/community/pull/34), что
82 | позволяет пользователям повторно использовать и делиться модульными
83 | функциями TensorFlow.
84 |
85 | ```python
86 | # TensorFlow 1.X
87 | outputs = session.run(f(placeholder), feed_dict={placeholder: input})
88 | # TensorFlow 2.0
89 | outputs = f(input)
90 | ```
91 |
92 | Благодаря возможности свободно перемежать код Python и TensorFlow пользователи
93 | могут воспользоваться преимуществами выразительности Python. Но переносимый
94 | TensorFlow выполняется в контекстах, таких как mobile, C ++ и JavaScript без
95 | интерпретатора Python. Чтобы пользователям не нужно было переписывать свой код
96 | при добавлении `@ tf.function`, [AutoGraph](function.ipynb) преобразует
97 | подмножество Python конструируя его в эквивалентах TensorFlow:
98 |
99 | * `for`/`while` -> `tf.while_loop` (`break` and `continue` are supported)
100 | * `if` -> `tf.cond`
101 | * `for _ in dataset` -> `dataset.reduce`
102 |
103 | AutoGraph поддерживает произвольные вложения control flow, что делает возможным
104 | эффективно и кратко реализовать многие сложные программы машинного обучения,
105 | такие как реккурентные модели, обучение с подкреплением, пользовательские циклы
106 | обучения и многое другое.
107 |
108 | ## Рекомендации характерные для TensorFlow 2.0
109 |
110 | ### Рефакторьте ваш код в меньшие функции
111 |
112 | Обычный пользовательский паттерн в TensorFlow 1.X была стратегия "kitchen
113 | sink"(кухонная мойка), где предварительно выкладывалось объединение всех
114 | возможных вычислений, а потом выбранные тензоры оценивались с `session.run()`. В
115 | TensorFlow 2.0, пользователям необходимо отрефакторить свой код в меньшие
116 | функции которые вызываются по мере необходимости. В общем, не обязательно
117 | декорировать каждую из этих функций с `tf.function`; используйте `tf.function`
118 | только для декорирования высокоуровневых вычислений - например, один шаг
119 | обучения или проход вперед в вашей модели.
120 |
121 | ### Используйте слои и модели Keras для управления переменными
122 |
123 |
124 | Keras models and layers offer the convenient `variables` and
125 | `trainable_variables` properties, which recursively gather up all dependent
126 | variables. This makes it easy to manage variables locally to where they are
127 | being used.
128 |
129 | Модели и слои Keras предлагают удобные свойства `variables` и
130 | `trainable_variables`, которые рекурсивно собирают все зависимые переменные. Это
131 | облегчает локальное управление переменными в том месте, где они использовались.
132 |
133 | Сравните:
134 |
135 | ```python
136 | def dense(x, W, b):
137 | return tf.nn.sigmoid(tf.matmul(x, W) + b)
138 |
139 | @tf.function
140 | def multilayer_perceptron(x, w0, b0, w1, b1, w2, b2 ...):
141 | x = dense(x, w0, b0)
142 | x = dense(x, w1, b1)
143 | x = dense(x, w2, b2)
144 | ...
145 |
146 | # Вам необходимо управлять w_i and b_i, а их размерности определены далеко от кода.
147 | ```
148 |
149 | с версией Keras:
150 |
151 | ```python
152 | # Каждый слой может быть вызван с сигнатурой эквивалентной linear(x)
153 | layers = [tf.keras.layers.Dense(hidden_size, activation=tf.nn.sigmoid) for _ in range(n)]
154 | perceptron = tf.keras.Sequential(layers)
155 |
156 | # layers[3].trainable_variables => returns [w3, b3]
157 | # perceptron.trainable_variables => returns [w0, b0, ...]
158 | ```
159 |
160 | Слои/модели Keras наследуются от `tf.train.Checkpointable` и интегрированы
161 | с `@ tf.function`, что позволяет напрямую проверять или экспортировать
162 | SavedModels из объектов Keras. Вам не обязательно использовать Keras
163 | `.fit ()` API чтобы воспользоваться этими интеграциями.
164 |
165 | Вот пример transfer learning, который демонстрирует, как Keras облегчает
166 | сбор подмножества релевантных переменных. Допустим, вы обучаете multi-headed
167 | model with a shared trunk:
168 |
169 | ```python
170 | trunk = tf.keras.Sequential([...])
171 | head1 = tf.keras.Sequential([...])
172 | head2 = tf.keras.Sequential([...])
173 |
174 | path1 = tf.keras.Sequential([trunk, head1])
175 | path2 = tf.keras.Sequential([trunk, head2])
176 |
177 | # Обучение на первичных данных
178 | for x, y in main_dataset:
179 | with tf.GradientTape() as tape:
180 | prediction = path1(x)
181 | loss = loss_fn_head1(prediction, y)
182 | # Одновременная оптимизация весов trunk и head1.
183 | gradients = tape.gradient(loss, path1.trainable_variables)
184 | optimizer.apply_gradients(zip(gradients, path1.trainable_variables))
185 |
186 | # Тонкая настройка второй head, переиспользование trunk
187 | for x, y in small_dataset:
188 | with tf.GradientTape() as tape:
189 | prediction = path2(x)
190 | loss = loss_fn_head2(prediction, y)
191 | # Оптимизируются только веса head2, не веса trunk
192 | gradients = tape.gradient(loss, head2.trainable_variables)
193 | optimizer.apply_gradients(zip(gradients, head2.trainable_variables))
194 |
195 | # Вы можете опубликовать только вычисления trunk чтобы другие люди могли ими воспользоваться.
196 | tf.saved_model.save(trunk, output_path)
197 | ```
198 |
199 | ### Комбинируйте tf.data.Datasets и @tf.function
200 |
201 | При итерации по тренировочным данным, которые помещаются в память, свободно
202 | используйте регулярную итерацию Python. Иначе, `tf.data.Dataset` - лучший способ
203 | для передачи тренировочных данных с диска. Данные являются
204 | [iterables (не iterators)](https://docs.python.org/3/glossary.html#term-iterable),
205 | и работают так же, как и другие Python iterables в режиме Eager. Вы можете
206 | полностью использовать свойства dataset async prefetching/streaming упаковав
207 | свой код в `tf.function ()`, которая заменяет итерацию Python эквивалентным
208 | графом операции использующим AutoGraph.
209 |
210 | ```python
211 | @tf.function
212 | def train(model, dataset, optimizer):
213 | for x, y in dataset:
214 | with tf.GradientTape() as tape:
215 | prediction = model(x)
216 | loss = loss_fn(prediction, y)
217 | gradients = tape.gradient(loss, model.trainable_variables)
218 | optimizer.apply_gradients(zip(gradients, model.trainable_variables))
219 | ```
220 |
221 | If you use the Keras `.fit()` API, you won't have to worry about dataset
222 | iteration.
223 |
224 | ```python
225 | model.compile(optimizer=optimizer, loss=loss_fn)
226 | model.fit(dataset)
227 | ```
228 |
229 | ### Воспользуйтесь преимуществами AutoGraph с Python control flow
230 |
231 | AutoGraph предоставляет способ преобразования зависящего от данных control flow
232 | в эквивалентый режим графа, например `tf.cond` и `tf.while_loop`.
233 |
234 | Одно обычное место, где появляется зависящий от данных control flow находится
235 | sequence models. `tf.keras.layers.RNN` оборачивает ячейку RNN, позволяя вам
236 | статически или динамически развернуть recurrence. Например, вы может
237 | переопределить динамическую развертку следующим образом:
238 |
239 | ```python
240 | class DynamicRNN(tf.keras.Model):
241 |
242 | def __init__(self, rnn_cell):
243 | super(DynamicRNN, self).__init__(self)
244 | self.cell = rnn_cell
245 |
246 | def call(self, input_data):
247 | # [batch, time, features] -> [time, batch, features]
248 | input_data = tf.transpose(input_data, [1, 0, 2])
249 | outputs = tf.TensorArray(tf.float32, input_data.shape[0])
250 | state = self.cell.zero_state(input_data.shape[1], dtype=tf.float32)
251 | for i in tf.range(input_data.shape[0]):
252 | output, state = self.cell(input_data[i], state)
253 | outputs = outputs.write(i, output)
254 | return tf.transpose(outputs.stack(), [1, 0, 2]), state
255 | ```
256 |
257 | Для более подробного обзора свойств AutoGraph, смотри
258 | [руководство](./function.ipynb).
259 |
260 | ### tf.metrics аггрегирует данные and tf.summary ведет их лог
261 |
262 | Для лога summaries используйте `tf.summary. (Scalar | histogram | ...)` и
263 | перенаправьте его на writer используя context manager. (Если вы опустите context
264 | manager, ничего случится.) В отличие от TF 1.x, summaries отправляются
265 | непосредственно writer; там нет отдельной операции "merge" и отдельного вызова
266 | `add_summary()`, что означает, что значение `step` должно быть указано на месте
267 | вызова.
268 |
269 | ```python
270 | summary_writer = tf.summary.create_file_writer('/tmp/summaries')
271 | with summary_writer.as_default():
272 | tf.summary.scalar('loss', 0.1, step=42)
273 | ```
274 |
275 | Чтобы объединить данные перед их записью в виде summaries, используйте
276 | `tf.metrics`. Метрика являются stateful: они накапливают значения и возвращают
277 | совокупный результат, когда вы вызовите `.result()`. Очистите накопленные
278 | значения с помощью `.reset_states ()`.
279 |
280 | ```python
281 | def train(model, optimizer, dataset, log_freq=10):
282 | avg_loss = tf.keras.metrics.Mean(name='loss', dtype=tf.float32)
283 | for images, labels in dataset:
284 | loss = train_step(model, optimizer, images, labels)
285 | avg_loss.update_state(loss)
286 | if tf.equal(optimizer.iterations % log_freq, 0):
287 | tf.summary.scalar('loss', avg_loss.result(), step=optimizer.iterations)
288 | avg_loss.reset_states()
289 |
290 | def test(model, test_x, test_y, step_num):
291 | loss = loss_fn(model(test_x), test_y)
292 | tf.summary.scalar('loss', loss, step=step_num)
293 |
294 | train_summary_writer = tf.summary.create_file_writer('/tmp/summaries/train')
295 | test_summary_writer = tf.summary.create_file_writer('/tmp/summaries/test')
296 |
297 | with train_summary_writer.as_default():
298 | train(model, optimizer, dataset)
299 |
300 | with test_summary_writer.as_default():
301 | test(model, test_x, test_y, optimizer.iterations)
302 | ```
303 |
304 | Визуализируйте сгенерированные результаты направив TensorBoard в директорий с
305 | summary log:
306 |
307 | ```
308 | tensorboard --logdir /tmp/summaries
309 | ```
310 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/r1/README.md:
--------------------------------------------------------------------------------
1 | # TensorFlow 1.x
2 |
3 | This archive of the TensorFlow 1.x docs is in *maintenance mode* only.
4 |
5 | For docs contributors, please update the source files in `site/en/` and read the
6 | [TensorFlow docs contributor guide](https://www.tensorflow.org/community/contribute/docs).
7 |
8 | For community translations, read the instructions in `site/ru/README.md`.
9 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/r1/guide/effective_tf2.md:
--------------------------------------------------------------------------------
1 | # Как использовать TensorFlow 2.0?
2 |
3 | Note: Вся информация в этом разделе переведена с помощью русскоговорящего
4 | Tensorflow сообщества на общественных началах. Поскольку этот перевод не
5 | является официальным, мы не гарантируем что он на 100% аккуратен и соответствует
6 | [официальной документации на английском языке](https://www.tensorflow.org/?hl=en).
7 | Если у вас есть предложение как исправить этот перевод, мы будем очень рады
8 | увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs)
9 | репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow
10 | лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим),
11 | напишите нам на
12 | [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru).
13 |
14 | В TensorFlow 2.0 были сделаны несколько изменений, которые позволят всем пользователям TensorFlow
15 | работать более продуктивно. В TensorFlow 2.0 были удалены
16 | [ненужные API](https://github.com/tensorflow/community/blob/master/rfcs/20180827-api-names.md),
17 | существующие и используемые API были проработаны
18 | ([объединены RNN](https://github.com/tensorflow/community/blob/master/rfcs/20180920-unify-rnn-interface.md),
19 | [а также оптимизаторы](https://github.com/tensorflow/community/blob/master/rfcs/20181016-optimizer-unification.md)),
20 | улучшена интеграция с рабочей средой Python в режиме
21 | [Eager execution](https://www.tensorflow.org/guide/eager).
22 |
23 | Во многих
24 | [запросах RFC](https://github.com/tensorflow/community/pulls?utf8=%E2%9C%93&q=is%3Apr)
25 | объяснялись основные изменения, которые затронут TensorFlow 2.0. В этом документе
26 | будет показано, как должен выглядеть процесс работы с новым TensorFlow 2.0.
27 | Подразумевается, что вы уже знакомы с TensorFlow 1.x.
28 |
29 | ## Краткий список основных изменений
30 |
31 | ### Чистка API
32 |
33 | Многие API были либо
34 | [удалены, либо перемещены](https://github.com/tensorflow/community/blob/master/rfcs/20180827-api-names.md)
35 | в TF 2.0. Самыми крупными изменениями являются удаление `tf.app`, `tf.flags`, а также
36 | `tf.logging` в пользу новой библиотеки с открытым исходным кодом
37 | [absl-py](https://github.com/abseil/abseil-py), перемещение проектов, которые были в
38 | `tf.contrib`, а также чистка основного имени `tf.*`: редко используемые функции
39 | были объединены в отдельные модули, например `tf.math`. Некоторые API были заменены
40 | их 2.0 эквивалентами - `tf.summary`, `tf.keras.metrics`, и
41 | `tf.keras.optimizers`. Самый простой способ автоматически переименовать все функции -
42 | это воспользоваться [скриптом для обновления до 2.0](upgrade.md).
43 |
44 | ### Активный Eager execution
45 |
46 | В TensorFlow 1.X от пользователя требовалось вручную строить
47 | [абстрактное синтаксическое дерево](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE) (граф) при помощи API вызовов `tf.*`. Для этого было нужно вручную
48 | компилировать дерево, передавая набор получаемых и входящих тензоров к вызову
49 | `session.run()`. TensorFlow 2.0 теперь выполняет все операции мгновенно (точно
50 | так же, как и обычный Python), все графы и сессии теперь будут работать как
51 | стандартное выполнение операций.
52 |
53 | Раньше побочным продуктом eager execution был метод `tf.control_dependencies()`,
54 | который теперь не треубется, и все строки кода будут исполняться в последовательном
55 | порядке, определенном `tf.function`. Сторонний код будет выполняться в
56 | определенном ему порядке.
57 |
58 | ### Никаких глобальных переменных
59 |
60 | TensorFlow 1.X внутренне полагался на глобальные переменные. Когда вы вызывали
61 | `tf.Variable()`, то эта переменная помещалась в стандартный граф и оставалась там
62 | даже если уже было изменено имя, присвоенное этой переменной. Вы могли восстановить
63 | эту переменную `tf.Variable`, но только если тебе было известно имя, которое было
64 | присвоено ей при создании. В результате все механизмы были направлены на то, чтобы
65 | помочь пользователю отыскать имя их переменных еще раз: `tf.get_global_step()`,
66 | `tf.global_variables_initializer()`, оптимизаторы, которые рассчитывали
67 | градиенты по всем обучаемым перменным и так далее. В TensorFlow 2.0 эти механизмы были
68 | устранены ([Переменные 2.0 RFC](https://github.com/tensorflow/community/pull/11))
69 | в пользу нового: следи за состоянием рабочих переменных! Если вы потеряете `tf.Variable`
70 | (например, ей будет присвоено новое имя), то старая будет удалена из памяти в порядке
71 | процесса garbage collection.
72 |
73 | Требование следить за переменными создает дополнительную нагрузку на пользователя,
74 | но в случае с объектами Keras (см. ниже), это нагрузка - минимальная.
75 |
76 | ### Функции, а не сессии
77 |
78 | Вызов `session.run()` работал почти как вызов функции: вы определяли вводные данные
79 | и вызывал функцию, получая на выходе результаты. В TensorFlow 2.0, вы можете
80 | декорировать функцию Python при помощи `tf.function()`, отметив её как JIT-компилируемую,
81 | чтобы TensorFlow запустил ее на одном единственном графе
82 | ([Функции 2.0 RFC](https://github.com/tensorflow/community/pull/20)). Этот
83 | механизм позволяет TensorFlow 2.0 получить все преимущества режима graph:
84 |
85 | - Производительность: функции могут быть оптимизированы (отсечение узлов графа,
86 | слияние ядра и так далее)
87 | - Портативность: Функции могут быть экспортированы
88 | или импортированы повторно ([Сохранение моделей 2.0 RFC](https://github.com/tensorflow/community/pull/34)),
89 | позволяя пользователям использовать модульные функции TensorFlow и делиться ими.
90 |
91 | ```python
92 | # TensorFlow 1.X
93 | outputs = session.run(f(placeholder), feed_dict={placeholder: input})
94 | # TensorFlow 2.0
95 | outputs = f(input)
96 | ```
97 |
98 | С новой возможностью просто использовать вместе код Python и TensorFlow, мы ожидаем
99 | что пользователи воспользуются всеми преимуществами выразительности языка Python.
100 | Но портативный TensorFlow выполняет операции в окружении без интерпретатора Python -
101 | на мобильных устройствах, C++ и JavaScript. Чтобы помочь пользователям легко переписать
102 | свой код при использовании новой `@tf.function`, используй [AutoGraph](autograph.ipynb)
103 | для конвертации кода Python в их эквиваленты TensorFlow:
104 |
105 | * `print` -> `tf.print`
106 | * `assert` -> `tf.Assert`
107 | * `for`/`while` -> `tf.while_loop` (поддерживаются `break` и `continue`)
108 | * `if` -> `tf.cond`
109 | * `for _ in dataset` -> `dataset.reduce`
110 |
111 | AutoGraph поддерживает вложенные функции в порядке выполнения программы, что
112 | делает возможным производительно и точно внедрять комплексные программы
113 | машинного обучения, например такие как последовательные модели, обучение с
114 | подкреплением, собственные циклы обучения и многие другие.
115 |
116 | ## Рекомендации и идиомы TensorFlow 2.0
117 |
118 | ### Рефакторинг кода на малые функции
119 |
120 | Часто используемый шаблон использования в TensorFlow 1.X работал по принципу
121 | kitchen sink ("кухонной раковины"), когда быа выложена совокупность всех возможных вычислений,
122 | а затем выбранные тензоры вычислялись с помощью `session.run()`. В TensorFlow 2.0
123 | пользователи должны сами разбивать код на более мелкие функции и вызывать каждую
124 | когда это необходимо. Необязательно декорировать каждую из этих небольших функций
125 | с `tf.function`; используй `tf.function` для декорирования только высокоуровневых
126 | вычислений - например, один шаг обучения или прямого прохода для модели.
127 |
128 | ### Используй слои и модели Keras для управления переменными
129 |
130 | Модели и слои Keras предлагают использовать удобное свойство `.variables`, которое
131 | рекурсивно собирает все зависимые переменные. Это значительно облегчает локальное управление
132 | переменными.
133 |
134 | Сравните:
135 |
136 | ```python
137 | def dense(x, W, b):
138 | return tf.nn.sigmoid(tf.matmul(x, W) + b)
139 |
140 | @tf.function
141 | def multilayer_perceptron(x, w0, b0, w1, b1, w2, b2 ...):
142 | x = dense(x, w0, b0)
143 | x = dense(x, w1, b1)
144 | x = dense(x, w2, b2)
145 | ...
146 |
147 | # Нам все равно придется управлять w_i и b_i, так как их формы определяются не в коде.
148 | ```
149 |
150 | Версия с использованием Keras:
151 |
152 | ```python
153 | # Каждый слой может быть вызван с сигнатурой равной linear(x)
154 | layers = [tf.keras.layers.Dense(hidden_size, activation=tf.nn.sigmoid) for _ in range(n)]
155 | perceptron = tf.keras.Sequential(layers)
156 |
157 | # layers[3].variables => returns [w3, b3]
158 | # perceptron.variables => returns [w0, b0, ...]
159 | ```
160 |
161 | Модели и слои Keras наследуются из `tf.train.Checkpointable` и интегрируются с
162 | `@tf.function`, что делает возможным сохранить или непосредственно экспортировать
163 | сохраненные модели из объектов Keras. Необязательно использовать метод `.fit()` из
164 | Keras API для этих интеграций.
165 |
166 | Вот пример transfer learning (переноса обучения), который демонстрирует как легко
167 | собрать подмножество необходимых переменных с помощью Keras. Предположим, мы обучаем
168 | разветвленную (multi-head) модель с общим корнем (trunk):
169 |
170 | ```python
171 | trunk = tf.keras.Sequential([...])
172 | head1 = tf.keras.Sequential([...])
173 | head2 = tf.keras.Sequential([...])
174 |
175 | path1 = tf.keras.Sequential([trunk, head1])
176 | path2 = tf.keras.Sequential([trunk, head2])
177 |
178 | # Обучаем на основном датасете:
179 | for x, y in main_dataset:
180 | with tf.GradientTape() as tape:
181 | prediction = path1(x)
182 | loss = loss_fn_head1(prediction, y)
183 | # Одновременно оптимизируем корень и веса первой ветви:
184 | gradients = tape.gradients(loss, path1.variables)
185 | optimizer.apply_gradients(gradients, path1.variables)
186 |
187 | # Настраиваем вторую ветвь, повторно используя корень:
188 | for x, y in small_dataset:
189 | with tf.GradientTape() as tape:
190 | prediction = path2(x)
191 | loss = loss_fn_head2(prediction, y)
192 | # Оптимизируем веса только второй ветви, без весов корня:
193 | gradients = tape.gradients(loss, head2.variables)
194 | optimizer.apply_gradients(gradients, head2.variables)
195 |
196 | #
197 | # Можем сохранить вычисления корня, чтобы другие также могли им воспользоваться.
198 | tf.saved_model.save(trunk, output_path)
199 | ```
200 |
201 | ### Объединение tf.data.Datasets и @tf.function
202 |
203 | При обучении модели на данных, которые находятся в памяти, используй стандартный
204 | итератор Python. В остальных случаях `tf.data.Dataset` является лучшим способом
205 | для потока тренировочных данных с диска. Датасеты являются
206 | [итерируемыми (не итераторами)](https://docs.python.org/3/glossary.html#term-iterable),
207 | и работают так же, как и другие итераторы Python в режиме Eager. Вы можете наиболее
208 | полно использовать асинхронные возможности prefetch и stream при помощи
209 | `tf.function()`, которая заменяет итерации Python их эквивалентами операций графов
210 | посредством AutoGraph.
211 |
212 | ```python
213 | @tf.function
214 | def train(model, dataset, optimizer):
215 | for x, y in dataset:
216 | with tf.GradientTape() as tape:
217 | prediction = model(x)
218 | loss = loss_fn(prediction, y)
219 | gradients = tape.gradients(loss, model.variables)
220 | optimizer.apply_gradients(gradients, model.variables)
221 | ```
222 |
223 | Если вы используете метод `.fit()` из Keras API, то вам не придется
224 | волноваться об итерации датасета.
225 |
226 | ```python
227 | model.compile(optimizer=optimizer, loss=loss_fn)
228 | model.fit(dataset)
229 | ```
230 |
231 | ### Воспользуйтесь премиуществами AutoGraph с порядком выполнения Python
232 |
233 | AutoGraph обеспечивает способ конвертации зависимого от данных порядка
234 | выполнения в его эквиваленты в режиме graph, например `tf.cond` и `tf.while_loop`.
235 |
236 | Единственное место, где появляется зависимый от данных порядок выполнения это
237 | последовательные модели. `tf.keras.layers.RNN` использует элемент RNN, позволяя
238 | вам развернуть повтор статически или динамически. Для примера, вы можете
239 | использовать динамическое развертывание:
240 |
241 | ```python
242 | class DynamicRNN(tf.keras.Model):
243 |
244 | def __init__(self, rnn_cell):
245 | super(DynamicRNN, self).__init__(self)
246 | self.cell = rnn_cell
247 |
248 | def call(self, input_data):
249 | # [батч, время, параметры] -> [время, батч, параметры]
250 | input_data = tf.transpose(input_data, [1, 0, 2])
251 | outputs = tf.TensorArray(tf.float32, input_data.shape[0])
252 | state = self.cell.zero_state(input_data.shape[1], dtype=tf.float32)
253 | for i in tf.range(input_data.shape[0]):
254 | output, state = self.cell(input_data[i], state)
255 | outputs = outputs.write(i, output)
256 | return tf.transpose(outputs.stack(), [1, 0, 2]), state
257 | ```
258 |
259 | Для более детального описание возможностей AutoGraph ознакомьтесь с
260 | [руководством](./autograph.ipynb).
261 |
262 | ### Используйте tf.metrics для сбора данных и tf.summary для логов
263 |
264 | Для записи логов, используйте `tf.summary.(scalar|histogram|...)`. Если использовать
265 | данные методы отдельно, то они не будут ничего делать; результаты должны быть
266 | перенаправлены к соответствующему file writer, при помощи контекстного менеджера
267 | (это позволит вам избежать записи логов в file writer).
268 |
269 | ```python
270 | summary_writer = tf.summary.create_file_writer('/tmp/summaries')
271 | with summary_writer.as_default():
272 | tf.summary.scalar('loss', 0.1, step=42)
273 | ```
274 |
275 | Чтобы собрать данные перед записью в лог, используйте `tf.metrics`. Метрики
276 | сохраняют свое состояние; они накапливают значения и возвращают собирательный
277 | результат, когда вы вызываете метод `.result()`. Чтобы очистить все значения
278 | используйте метод `.reset_states()`.
279 |
280 | ```python
281 | def train(model, optimizer, dataset, log_freq=10):
282 | avg_loss = tf.keras.metrics.Mean(name='loss', dtype=tf.float32)
283 | for images, labels in dataset:
284 | loss = train_step(model, optimizer, images, labels)
285 | avg_loss.update_state(loss)
286 | if tf.equal(optimizer.iterations % log_freq, 0):
287 | tf.summary.scalar('loss', avg_loss.result(), step=optimizer.iterations)
288 | avg_loss.reset_states()
289 |
290 | def test(model, test_x, test_y, step_num):
291 | loss = loss_fn(model(test_x), test_y)
292 | tf.summary.scalar('loss', loss, step=step_num)
293 |
294 | train_summary_writer = tf.summary.create_file_writer('/tmp/summaries/train')
295 | test_summary_writer = tf.summary.create_file_writer('/tmp/summaries/test')
296 |
297 | with train_summary_writer.as_default():
298 | train(model, optimizer, dataset)
299 |
300 | with test_summary_writer.as_default():
301 | test(model, test_x, test_y, optimizer.iterations)
302 | ```
303 |
304 | Указав папку с результами в TensorBoard (`tensorboard --logdir
305 | /tmp/summaries`), вы можете визуализировать полученные в ходе обучения
306 | данные на графиках.
307 |
308 |
309 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/r1/guide/estimators.md:
--------------------------------------------------------------------------------
1 | # Estimators
2 |
3 | Note: Вся информация в этом разделе переведена с помощью русскоговорящего
4 | Tensorflow сообщества на общественных началах. Поскольку этот перевод не
5 | является официальным, мы не гарантируем что он на 100% аккуратен и соответствует
6 | [официальной документации на английском языке](https://www.tensorflow.org/?hl=en).
7 | Если у вас есть предложение как исправить этот перевод, мы будем очень рады
8 | увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs)
9 | репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow
10 | лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим),
11 | напишите нам на
12 | [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru).
13 |
14 | В этом документе мы познакомимся `tf.estimator`, высокоуровневым API TensorFlow,
15 | который значительно упрощает процесс создания моделей машинного обучения.
16 | Estimators включает в себя следующие операции:
17 |
18 | * обучение
19 | * оценку
20 | * предсказание
21 | * экспорт модели на сервер
22 |
23 | Ты можешь использовать либо уже готовые Estimators или написать свои
24 | собственные для оценки. Все Estimators основаны на классе `tf.estimator.Estimator`.
25 |
26 | Для быстрого ознакомления попробуй запустить [интерактивные уроки по Estimator](../tutorials/estimators/linear.ipynb)
27 | в Google Colab. Чтобы узнать о каждой функции подробнее смотри статью [готовые Estimators](premade_estimators.md).
28 | Для ознакомления с дизайном этого API смотри наш [доклад на arxiv.org](https://arxiv.org/abs/1708.02637).
29 |
30 | Обрати внимание: TensorFlow также включает в себя устаревший класс
31 | `Estimator` в `tf.contrib.learn.Estimator`, который использовать не стоит.
32 |
33 |
34 | ## Преимущества Estimators
35 |
36 | Estimators обеспечивают следующие преимущества:
37 |
38 | * Можно запускать модели на основе Estimators локально или на распределенном
39 | сервере без изменений структуры модели. Более того, ты можешь запускать модели
40 | на CPU, GPU и TPU без внесения изменений в код
41 | * С помощью Estimators удобнее делиться своими моделями с другими разработчиками
42 | * Можно разрабатывать современные модели с читаемым высокоуровневым кодом. Проще говоря,
43 | гораздо легче создавать модели с Estimators, чем с низкоуровневым API TensorFlow
44 | * Сами Estimators построены на `tf.keras.layers`, которые упрощают настройку модели
45 | под себя
46 | * Estimators строят граф
47 | * Estimators обеспечивают простой распределенный цикл обучения, который контролирует
48 | как и когда:
49 |
50 | * строить граф
51 | * инициализировать переменные
52 | * загружать данные
53 | * обрабатывать исключения
54 | * создавать контрольные точки и восстанавливаться при неудачных попытках
55 | * сохранять статистику в TensorBoard
56 |
57 | При написании приложения с Estimators ты должен отделять загрузку входных данных
58 | от самой модели. Это разделение упрощает эксперименты с разными наборами данных.
59 |
60 |
61 | ## Готовые Estimators
62 |
63 | Готовые Estimators позволяют тебе работать на более высоком уровне, по сравнению
64 | с базовым API TensorFlow. Тебе больше не нужно волноваться о построении вычислительного
65 | графа или сессиях обучения, поскольку Estimators сами делают за тебя всю работу.
66 | Таким образом Estimators сами создают и управляют объектами `tf.Graph` и
67 | `tf.Session`. Более того, готовые Estimators позволяют тебе экспериментировать с
68 | разными архитектурами с минимальными изменениями исходного кода. Например,
69 | `tf.estimator.DNNClassifier` - это готовый класс Estimator, который обучает
70 | классификации модели на основе нейронной сети прямого распространения, которая
71 | состоит из *Dense* слоев.
72 |
73 |
74 | ### Структура программ с готовыми Estimators
75 |
76 | Программа TensorFlow на основе готовых Estimators обычно состоит из следующих
77 | четырех шагов:
78 |
79 | 1. **Написание одной или более функций для загрузки датасета**. Например,
80 | создадим функцию для импорта тренировочного сета и вторую функцию для
81 | импорта проверочного сета данных. Каждая функция для загрузки датасета
82 | должна возвращать два объекта:
83 |
84 | * словарь, в котором ключи являются именами параметров, а значения
85 | являются тензорами (или *SparseTensors*), содержащие соответствующие
86 | данные параметров
87 | * тензор, содержащий одну или более меток
88 |
89 | Например, в коде ниже показан пример основного скелета для функции ввода
90 | данных:
91 |
92 | ```python
93 | def input_fn(dataset):
94 | ... # манипулирует датасетом, извлекая словарь параметров и метки
95 | return feature_dict, label
96 | ```
97 |
98 | Смотри подробнее в статье [Загрузка данных и датасетов](../guide/datasets.md)
99 |
100 | 2. **Определение колонок параметров.** Каждая колонка `tf.feature_column`
101 | определяет имя параметра, его тип и любую предварительную обработку
102 | входных данных. Например, в следующем примере кода мы создадим три
103 | колонки параметров, в которых будут храниться данные в формате целых
104 | чисел или чисел с плавающей запятой. Первые две колонки параметров будут
105 | просто идентифицировать имя и тип параметра. Третья колонка параметров указывает
106 | на лямбду-выражение, которое будут вызываться для оценки необработанных
107 | данных:
108 |
109 | ```python
110 | # Определим три числовых колонки параметров.
111 | population = tf.feature_column.numeric_column('population')
112 | crime_rate = tf.feature_column.numeric_column('crime_rate')
113 | median_education = tf.feature_column.numeric_column('median_education',
114 | normalizer_fn=lambda x: x - global_education_mean)
115 | ```
116 |
117 | 3. **Укажем подходящий готовый Estimator.** Например так мы укажем
118 | готовый Estimator для решения модели `линейного классификатора`:
119 |
120 | ```python
121 | # Указываем estimator, передаем колонки параметров.
122 | estimator = tf.estimator.LinearClassifier(
123 | feature_columns=[population, crime_rate, median_education],
124 | )
125 | ```
126 |
127 | 4. **Вызов метода обучения, оценки или предсказания**
128 | Например, все Estimators имеют метод `train` для начала обучения модели:
129 |
130 | ```python
131 | # `input_fn` - функция, созданная в самом первом шаге
132 | estimator.train(input_fn=my_training_set, steps=2000)
133 | ```
134 |
135 | ### Преимущества использования готовых Estimators
136 |
137 | В готовых Estimators используются лучшие практики, которые обеспечивают
138 | следующие преимущества:
139 |
140 | * Лучшие практики для определения какие части вычислительного графа
141 | запускать сначала, а также стратегии для обучения на одном устройстве
142 | или целом кластере
143 | * Стандартизированная практика ведения логов и получения полезной статистики
144 |
145 | Если ты не собираешься использовать готовые Estimators, то тогда тебе
146 | придется указывать все необходимые параметры самому.
147 |
148 |
149 | ## Собственные Estimators
150 |
151 | Ядром каждого Estimator, готового или написанного с нуля, является
152 | **функция модели**, которая представляет из себя метод для построения
153 | графа для обучения, оценки и предсказаний. Когда ты используешь готовый
154 | Estimator, кто-то уже написал функцию модели для тебя. В том случае,
155 | когда ты полагаешься на свой собственный Estimator, ты должен сам
156 | написать эту функцию. Более подробно о том, как написать функцию модели
157 | ты можешь узнать в статье [Написание собственных Estimators](../guide/custom_estimators.md)
158 |
159 |
160 | ## Рекомендуемый ход работы
161 |
162 | Мы рекомендуем следующий порядок создания модели с помощью Estimators:
163 |
164 | 1. Предположим, что есть готовый Estimator, и мы используем его для
165 | построения нашей модели, а также используем результаты оценки для
166 | формирования эталонной модели
167 | 2. Создаем и тестируем процесс загрузки данных, проверяем целостность и
168 | надежность наших данных с готовым Estimator
169 | 3. Если есть другие подходящие альтернативы, тогда экспериментируем с ними
170 | для поиска Estimator, который покажет лучшие результаты
171 | 4. Возможно потребуется улучшить нашу модель при помощи создания нашего
172 | собственного Estimator.
173 |
174 |
175 | ## Создание Estimators из моделей Keras
176 |
177 | Ты можешь конвертировать уже имеющиеся у тебя модели Keras в Estimators. Это позволит
178 | тебе использовать все преимущества Estimators для данной модели, например, для распределенного
179 | обучения. Вызови функцию `tf.keras.estimator.model_to_estimator` как в примере ниже:
180 |
181 | ```python
182 | # Создаем модель Inception v3 в Keras:
183 | keras_inception_v3 = tf.keras.applications.inception_v3.InceptionV3(weights=None)
184 |
185 | # Компилируем модель с оптимизатором, функцией потерь и метриками обучения по выбору.
186 | keras_inception_v3.compile(optimizer=tf.keras.optimizers.SGD(lr=0.0001, momentum=0.9),
187 | loss='categorical_crossentropy',
188 | metric='accuracy')
189 |
190 | # Создаем Estimator из скомпилированной модели Keras. Обрати внимание, что изначальное
191 | # состояние модели Keras сохраняется при создании Estimator.
192 | est_inception_v3 = tf.keras.estimator.model_to_estimator(keras_model=keras_inception_v3)
193 |
194 | # Теперь мы можем использовать полученный Estimator как любой другой.
195 | # Для начала восстановим вводное имя (или имена) модели Keras, чтобы мы могли использовать их
196 | # как имена колонок параметров функции ввода данных Estimator:
197 | keras_inception_v3.input_names # выводит: ['input_1']
198 |
199 | # Как только мы получим вводные имена, мы можем создать функцию ввода данных, например,
200 | # для входа данных в формате NumPy ndarray:
201 | train_input_fn = tf.estimator.inputs.numpy_input_fn(
202 | x={"input_1": train_data},
203 | y=train_labels,
204 | num_epochs=1,
205 | shuffle=False)
206 |
207 | # Для обучения вызываем функцию `train` полученного нами Estimator:
208 | est_inception_v3.train(input_fn=train_input_fn, steps=2000)
209 | ```
210 |
211 | Обрати внимание, что имена колонок параметров и меток Esitmator мы получили
212 | из соответствующей модели Keras. Например, имена вводных ключей для `train_input_fn`
213 | выше могут быть получены из `keras_inception_v3.input_names`, и таким же образом
214 | предсказанные имена могут быть получены из `keras_inception_v3.output_names`.
215 |
216 | Подробнее смотри документацию в статье `tf.keras.estimator.model_to_estimator`.
217 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/r1/guide/tensors.md:
--------------------------------------------------------------------------------
1 | # Тензоры
2 |
3 | Note: Вся информация в этом разделе переведена с помощью русскоговорящего
4 | Tensorflow сообщества на общественных началах. Поскольку этот перевод не
5 | является официальным, мы не гарантируем что он на 100% аккуратен и соответствует
6 | [официальной документации на английском языке](https://www.tensorflow.org/?hl=en).
7 | Если у вас есть предложение как исправить этот перевод, мы будем очень рады
8 | увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs)
9 | репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow
10 | лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим),
11 | напишите нам на
12 | [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru).
13 |
14 | Как понятно из названия, TensorFlow ("поток тензоров") - это фреймворк для определения
15 | и вычисления операций с тензорами. Тензор - это обобщенное название векторов и матриц,
16 | вплоть до потенциально высоких размерностей. Во внутренней структуре TensorFlow
17 | векторы представлены как n-размерные массивы примитивных типов данных.
18 |
19 | При написании программ в TensorFlow ключевым объектом всех операций является
20 | `tf.Tensor`. Этот объект представляет собой частично определенное вычисление,
21 | которое в конечном итоге выдаст какое-либо значение. Программы TensorFlow
22 | сначала строят граф объектов `tf.Tensor`, детализирует как каждый тензор будет
23 | вычисляться на других доступных тензорах, а затем запускает построение этого
24 | графа для получения желаемых результатов.
25 |
26 | Объект `tf.Tensor` имеет следующие параметры:
27 |
28 |
29 | * тип данных (например`float32`, `int32`, или `string`)
30 | * форму (a shape)
31 |
32 |
33 | Каждый элемент в тензоре имеет одинаковый тип данных, и этот тип всегда известен.
34 | Размерность, которая определяется количеством размерностей и размером каждого
35 | массива, может быть известна частично. Большинство операций производят
36 | тензоры полностью известных размерностей, если эти входные размерности также
37 | известны, но в некоторых случаях узнать размерность тензора можно только в режиме
38 | graph execution.
39 |
40 | Некоторые типы тензоров являются специализированными, и будут описаны в
41 | других статьях руководства по TensorFlow. Ключевыми являются:
42 |
43 | * `tf.Variable`
44 | * `tf.constant`
45 | * `tf.placeholder`
46 | * `tf.SparseTensor`
47 |
48 |
49 | За исключением `tf.Variable`, значение тензора является неизменным, что означает
50 | в контексте единичного вычисления тензор будет иметь всего одно значение. Однако,
51 | при вычислении одного и того же тензора дважды, он может возвращать разные значения;
52 | например, тензор может быть результатом прочтения данных с диска, или случайно
53 | сгенерированного числа.
54 |
55 |
56 | ## Ранг
57 |
58 |
59 | **Ранг** объекта `tf.Tensor` - это количество размерностей массива. Синонимами
60 | ранга являются **порядок**, **степень** или **n-размерность**.
61 | Обрати внимание, что ранг в TensorFlow это не то же самое, что ранг матрицы в
62 | математике. Из следующей таблицы видно, что каждый ранг в TensorFlow соответствует
63 | разным математическим категориям:
64 |
65 |
66 | Ранг | Математическая категория
67 | --- | ---
68 | 0 | Скаляр (только величина)
69 | 1 | Вектор (величина и направление)
70 | 2 | Матрица (таблица чисел)
71 | 3 | 3-Тензор (куб чисел)
72 | n | n-Тензор (ты понял идею)
73 |
74 |
75 | ### Ранг 0
76 |
77 | Следующий пример кода демонстрирует создание нескольких переменных
78 | ранга 0:
79 |
80 | ```python
81 | mammal = tf.Variable("Elephant", tf.string)
82 | ignition = tf.Variable(451, tf.int16)
83 | floating = tf.Variable(3.14159265359, tf.float64)
84 | its_complicated = tf.Variable(12.3 - 4.85j, tf.complex64)
85 | ```
86 |
87 |
88 | Обрати внимание: строка в TensorFlow является одним объектом, а не последовательностью
89 | символов. Возможно также использовать скалярные строки, вектор строк и так далее.
90 |
91 | ### Ранг 1
92 |
93 |
94 | Чтобы создать объект `tf.Tensor` ранга 1, ты можешь передать список элементов
95 | как первичное значение. Например:
96 |
97 | ```python
98 | mystr = tf.Variable(["Hello"], tf.string)
99 | cool_numbers = tf.Variable([3.14159, 2.71828], tf.float32)
100 | first_primes = tf.Variable([2, 3, 5, 7, 11], tf.int32)
101 | its_very_complicated = tf.Variable([12.3 - 4.85j, 7.5 - 6.23j], tf.complex64)
102 | ```
103 |
104 |
105 | ### Высшие ранги
106 |
107 |
108 | Ранг 2 объекта `tf.Tensor` состоит из как минимум одного ряда и одного
109 | столбца:
110 |
111 | ```python
112 | mymat = tf.Variable([[7],[11]], tf.int16)
113 | myxor = tf.Variable([[False, True],[True, False]], tf.bool)
114 | linear_squares = tf.Variable([[4], [9], [16], [25]], tf.int32)
115 | squarish_squares = tf.Variable([ [4, 9], [16, 25] ], tf.int32)
116 | rank_of_squares = tf.rank(squarish_squares)
117 | mymatC = tf.Variable([[7],[11]], tf.int32)
118 | ```
119 |
120 |
121 | Тензоры высшего ранга подобным образом состоят из n-размерных массивов. Например,
122 | во время обработки изображения используются тензоры ранга 4 с соответствующими
123 | им размерносятми примеров в батче, шириной и высотой изображения, и цветовой модели.
124 |
125 | ``` python
126 | my_image = tf.zeros([10, 299, 299, 3]) # batch x height x width x color
127 | ```
128 |
129 | ### Получаем ранг объекта `tf.Tensor`
130 |
131 |
132 | Чтобы определить ранг объекта `tf.Tensor`, вызови метод `tf.rank`. Например,
133 | следующий метод программным способом определит ранг `tf.Tensor`, определенного
134 | в предыдущем блоке кода:
135 |
136 | ```python
137 | r = tf.rank(my_image)
138 | # После запуска графа, r присвоится значение 4.
139 | ```
140 |
141 | ### Работаем с частями `tf.Tensor`
142 |
143 |
144 | Поскольку `tf.Tensor` является n-размерным массивом элементов, то для доступа к
145 | конкретному элементу `tf.Tensor` потребуется уточнить индексы n.
146 |
147 |
148 | Для тензора ранг 0 (скаляра) не требуется никаких индексов, посколько это
149 | и есть одно единственное значение.
150 |
151 |
152 | Для тензора ранга 1 (вектора) потребуется передать всего один индекс, который
153 | предоставит нам доступ к значению:
154 |
155 |
156 | ```python
157 | my_scalar = my_vector[2]
158 | ```
159 |
160 |
161 | Обрати внимание, что индекс, передаваемый внутри `[]`, может сам быть скалярным
162 | `tf.Tensor`, если ты хочешь динамически выбирать элементы из вектора.
163 |
164 |
165 | С тензорами ранга 2 и выше ситуация более интересная. Передавая два значения
166 | `tf.Tenosor` ранга 2, он возвращает скаляр, что вполне ожидаемо:
167 |
168 |
169 | ```python
170 | my_scalar = my_matrix[1, 2]
171 | ```
172 |
173 |
174 | Однако, передавая одно единственное значение, он возвращает подвектор матрицы как
175 | в этом примере:
176 |
177 |
178 | ```python
179 | my_row_vector = my_matrix[2]
180 | my_column_vector = my_matrix[:, 3]
181 | ```
182 |
183 |
184 | Нотация `:` в Python делит синтаксис, оставляя эту размерность "в покое". Этот
185 | прием полезен при работе с тензорами высшего ранга, поскольку предоставляет
186 | доступ к его подвекторам, подматрицам и даже подтензорам.
187 |
188 |
189 | ## Форма
190 |
191 |
192 | **Форма** тензора - это количество элементов в каждой размерности.
193 | TensorFlow автоматически назначает формы во время работы в graph execution.
194 | Назначенные формы могут иметь известный или неизвестный ранг. Если ранг
195 | известен, то элементы каждой размерности также могут быть известны или
196 | неизвестны.
197 |
198 |
199 | В документации TensorFlow используются три правила для описания размерности
200 | тензоров: ранг, форма и номер размерности. В следующией таблице видно, как эти
201 | три параметра соотносятся друг с другом:
202 |
203 | Ранг | Форма | Номер размерности | Пример
204 | --- | --- | --- | ---
205 | 0 | [] | 0-D | Тензор 0-D . Скаляр.
206 | 1 | [D0] | 1-D | Тензор 1-D формы [5].
207 | 2 | [D0, D1] | 2-D | Тензор 2-D формы [3, 4].
208 | 3 | [D0, D1, D2] | 3-D | Тензор 3-D формы [1, 4, 3].
209 | n | [D0, D1, ... Dn-1] | n-D | Тензор формы [D0, D1, ... Dn-1].
210 |
211 |
212 | Формы могут быть представлены в Python как списки или кортежи целых чисел,
213 | или как `tf.TensorShape`
214 |
215 | ### Получаем форму объекта `tf.Tensor`
216 |
217 |
218 | Есть два способа получить форму `tf.Tensor`. Во время построения графа часто
219 | является полезным узнать, что уже известно о форме тензора. Это можно сделать
220 | прочтя параметр `shape` объека `tf.Tensor`. Этот метод возвращает объект
221 | `TensorShape`, который является весьма удобным способом представления
222 | частично определенных форм, поскольку во время построения графа не все формы
223 | известны полностью.
224 |
225 |
226 | Также возможно получить `tf.Tensor`, который будет представлять полностью
227 | определенную форму другого объекта `tf.Tensor` в рабочей среде. Это достигается
228 | путем вызова операции `tf.shape`. Таким образом ты можешь построить граф, который
229 | манипулирует формами тензоров при помощи создания других тензоров, который зависят
230 | от динамической формы входящего `tf.Tensor`.
231 |
232 |
233 | Например, вот как мы можем сделать вектор из нулей с одинаковым размером и числом
234 | столбцов в матрице:
235 |
236 | ``` python
237 | zeros = tf.zeros(my_matrix.shape[1])
238 | ```
239 |
240 |
241 | ### Изменяем форму `tf.Tensor`
242 |
243 |
244 | **Количество элементов** тензора - это продукт размеров всех форм. Количество
245 | элементов - это скаляр, который всегда равен `1`. Посколько часто множесто разных
246 | форм имеют одинаковое количество элементов, то часто удобно позволять менять форму
247 | `tf.Tensor`, зафиксировав его элементы. Это можно сделать с помощью `tf.reshape`.
248 |
249 | В следующем примере показано как изменить форму тензоров:
250 |
251 | ```python
252 | rank_three_tensor = tf.ones([3, 4, 5])
253 | matrix = tf.reshape(rank_three_tensor, [6, 10]) # Изменяем существующую форму на
254 | # матрицу 6x10
255 | matrixB = tf.reshape(matrix, [3, -1]) # Изменяем форму на матрицу 3х20.
256 | # -1 требует `reshape` рассчитать
257 | # размерность тензора.
258 | matrixAlt = tf.reshape(matrixB, [4, 3, -1]) # Изменяем форму на
259 | # тензор 4х3х5
260 |
261 | # Обрати внимание, что количество элементов измененных тензоров должно совпадать
262 | # с изначальным количеством элементов. Таким образом, следующий пример выдает
263 | # ошибку, так как нет значения для последней размерности, которое бы совпадало
264 | # с количеством элементов.
265 | yet_another = tf.reshape(matrixAlt, [13, 2, -1]) # Ошибка!
266 | ```
267 |
268 | ## Типы данных
269 |
270 |
271 | В дополнение к размерностям, тензоры имеют тип данных. Смотри документацию
272 | `tf.DType` для ознакомления с полным списком типов данных.
273 |
274 |
275 | Невозможно иметь `tf.Tensor` более чем с одним типом данных. Тем не менее, возможно
276 | сериализовать произвольные структуры данных как строки и сохранить их в `tf.Tensor`.
277 |
278 |
279 | Также возможно конвертировать тип данных из одного `tf.Tensor` в другой при помощи
280 | метода `tf.cast`:
281 |
282 |
283 | ``` python
284 | # Переводим константу тензора в число с плавающей запятой.
285 | float_tensor = tf.cast(tf.constant([1, 2, 3]), dtype=tf.float32)
286 | ```
287 |
288 |
289 | Для проверки тип данных `tf.Tensor` используй параметр `Tensor.dtype`.
290 |
291 |
292 | При создании `tf.Tensor` из объекта Python, ты можешь также указать тип данных
293 | этого тензора. Если этого не сделать, то TensorFlow сам выберет тип данных,
294 | который будет представлять твои данные. TensorFlow автоматически конвертирует
295 | *целые числа* Python в `tf.int32`, а *числа с плавающей запятой* - в `tf.float32`.
296 | Другими словами, TensorFlow использует те же самые правила, что и NumPy при
297 | конвертации в массивы.
298 |
299 |
300 | ## Оценка тензоров
301 |
302 |
303 | Когда вычислительный граф был построен, ты можешь запустить вычисление, которое
304 | будет производить определенный `tf.Tensor` и извлекать присвоенное ему значение.
305 | Это часто является полезным как для отладки, так и необходимо для работы TensorFlow.
306 |
307 |
308 | Самый легкий способ оценить тензор - использовать метод `Tensor.eval`. Вот пример
309 | кода оценки тензора:
310 |
311 |
312 | ```python
313 | constant = tf.constant([1, 2, 3])
314 | tensor = constant * constant
315 | print(tensor.eval())
316 | ```
317 |
318 |
319 | Метод `eval` работает только когда активирована стандартная `tf.Session`
320 | (смотри [Графы и сессии](https://www.tensorflow.org/guide/graphs) для
321 | более подробной информации).
322 |
323 |
324 | `Tensor.eval` возвращает массив NumPy с тем же самым содержимым, что и
325 | тензор.
326 |
327 |
328 | Иногда невозможно произвести оценку `tf.Tensor` без контекста, потому что
329 | его значение может зависеть от динамичности информации, которая недоступна.
330 | Например, тензоры, которые зависят от `placeholder`' не могут быть оценены
331 | без присвоения значения для `placeholder`.
332 |
333 | ``` python
334 | p = tf.placeholder(tf.float32)
335 | t = p + 1.0
336 | t.eval() # Эта операция не будет выполнена, так как нет значения.
337 | t.eval(feed_dict={p:2.0}) # Эта операция будет произведены успешно, поскольку
338 | # мы присваиваем значение placeholder.
339 | ```
340 |
341 |
342 | Отемтим, что возможно производить оценку любых `tf.Tensor`, а не только
343 | placeholder.
344 |
345 |
346 | Другие структуры модели могут усложнить оценку `tf.Tensor`. TensorFlow
347 | не может напрямую оценить `tf.Tensor`, определенные внутри функций или внутри
348 | порядка выполнения структуры модели. Если `tf.Tensor` зависит от значения из
349 | очереди, то оценка `tf.Tensor` будет работать только если какое-то значение
350 | было поставлено в очередь; в других случаях оценка будет приостановлена. При
351 | работе с очередями, всегда вызывай `tf.train.start_queue_runners` прежде чем
352 | производить оценку каких-либо `tf.Tensor`.
353 |
354 |
355 | ## Выводим значения тензоров
356 |
357 |
358 | Чтобы произвести отладку коду возможно понадобится выводить значения `tf.Tensor`.
359 | Несмотря на то, что [tfdbg](../guide/debugger.md) хоть и предлагает углубленную
360 | поддержку отладки, TensorFlow также имеет операцию для неспоредственного вывода
361 | значения `tf.Tensor` на экран.
362 |
363 |
364 | Отметим, что только в редких случаях потребуется использовать следующий
365 | шаблон для вывода значения `tf.Tensor`:
366 |
367 |
368 | ``` python
369 | t = <<здесь определена операция tensorflow>>
370 | print(t) # Выводим символический тензор при построении графа.
371 | # Этот тензор не имеет значения в данном контексте.
372 | ```
373 |
374 |
375 | Этот код выведет на экран объект `tf.Tensor` (который представляет из себя
376 | отложенное вычисление), но не его значение. Вместо этого TensorFlow обеспечит
377 | операцию `tf.Print`, которая возвратит его первый неизменный аргумент тензора,
378 | в то время как также выведет набор `tf.Tensor`, который был передан как второй
379 | аргумент.
380 |
381 |
382 | Чтобы правильно использовать `tf.Print`, необходимо использовать его возвращенное
383 | значение как в примере ниже:
384 |
385 |
386 | ``` python
387 | t = <<какая-либо операция tensorflow>>
388 | tf.Print(t, [t]) # Не возвращает ничего
389 | t = tf.Print(t, [t]) # Здесь мы используем значение, возвращенное `tf.Print`.
390 | result = t + 1 # Теперь результат оценен, и значение `t` будет выведено.
391 | ```
392 |
393 |
394 | При оценке `result` мы также оцениваем все, от чего зависит `result`.
395 | Поскольку `result` зависит от `t` и оценка `t` окажет эффект на вывод его
396 | значения (предыдущего значения `t`), значение `t` будет выведено на экран.
397 |
398 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/r1/tutorials/keras/README.md:
--------------------------------------------------------------------------------
1 | # Изучай и применяй методы машинного обучения
2 |
3 | Note: Вся информация в этом разделе переведена с помощью русскоговорящего
4 | Tensorflow сообщества на общественных началах. Поскольку этот перевод не
5 | является официальным, мы не гарантируем что он на 100% аккуратен и соответствует
6 | [официальной документации на английском языке](https://www.tensorflow.org/?hl=en).
7 | Если у вас есть предложение как исправить этот перевод, мы будем очень рады
8 | увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs)
9 | репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow
10 | лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим),
11 | напишите нам на
12 | [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru).
13 |
14 | Создать серию интерактивных руководств нас вдохновила книга
15 | *[Глубокое обучение на Python](https://books.google.com/books?id=Yo3CAQAACAAJ)*.
16 | В наших уроках используется высокоуровневый `tf.keras` API для создания
17 | и обучения моделей глубокого обучения. Узнай больше о том, как использовать Keras
18 | и TensorFlow в нашем [Руководстве по TensorFlow и Keras](../../guide/keras.ipynb).
19 |
20 | Примечание издателя: *Глубокое обучение на Python* представляет из себя
21 | практическое пособие для создания моделей глубокого обучения на Python,
22 | используя все возможности библиотеки Keras. Книга написана Франсуа Шолле, автором
23 | библиотеки и научным сотрудником Google AI. Она поможет тебе понять
24 | основные методы глубокого обучения с помощью наглядных объяснений и практических примеров.
25 |
26 | Чтобы узнать больше об основах машинного обучения, начни
27 | [Ускоренный курс по машинному обучению](https://developers.google.com/machine-learning/crash-course/).
28 |
29 | 1. [Простая классификация](./basic_classification.ipynb)
30 | 2. [Классификация текста](./basic_text_classification.ipynb)
31 | 3. [Регрессия](./basic_regression.ipynb)
32 | 4. [Переобучение и недообучение](./overfit_and_underfit.ipynb)
33 | 5. [Сохранение и загрузка моделей](./save_and_restore_models.ipynb)
34 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/tutorials/keras/text_classification_with_hub.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "text_classification_with_hub.ipynb",
7 | "version": "0.3.2",
8 | "provenance": [],
9 | "private_outputs": true,
10 | "collapsed_sections": [],
11 | "toc_visible": true
12 | },
13 | "kernelspec": {
14 | "display_name": "Python 3",
15 | "name": "python3"
16 | }
17 | },
18 | "cells": [
19 | {
20 | "cell_type": "markdown",
21 | "metadata": {
22 | "colab_type": "text",
23 | "id": "Ic4_occAAiAT"
24 | },
25 | "source": [
26 | "##### Copyright 2019 The TensorFlow Authors."
27 | ]
28 | },
29 | {
30 | "cell_type": "code",
31 | "metadata": {
32 | "cellView": "form",
33 | "colab_type": "code",
34 | "id": "ioaprt5q5US7",
35 | "colab": {}
36 | },
37 | "source": [
38 | "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
39 | "# you may not use this file except in compliance with the License.\n",
40 | "# You may obtain a copy of the License at\n",
41 | "#\n",
42 | "# https://www.apache.org/licenses/LICENSE-2.0\n",
43 | "#\n",
44 | "# Unless required by applicable law or agreed to in writing, software\n",
45 | "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
46 | "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
47 | "# See the License for the specific language governing permissions and\n",
48 | "# limitations under the License."
49 | ],
50 | "execution_count": 0,
51 | "outputs": []
52 | },
53 | {
54 | "cell_type": "markdown",
55 | "metadata": {
56 | "colab_type": "text",
57 | "id": "ItXfxkxvosLH"
58 | },
59 | "source": [
60 | "# Классификация текстов обзоров фильмов с Keras и TensorFlow Hub"
61 | ]
62 | },
63 | {
64 | "cell_type": "markdown",
65 | "metadata": {
66 | "colab_type": "text",
67 | "id": "hKY4XMc9o8iB"
68 | },
69 | "source": [
70 | ""
84 | ]
85 | },
86 | {
87 | "cell_type": "markdown",
88 | "metadata": {
89 | "id": "fj66ZXAzrJC2",
90 | "colab_type": "text"
91 | },
92 | "source": [
93 | "Note: Вся информация в этом разделе переведена с помощью русскоговорящего Tensorflow сообщества на общественных началах. Поскольку этот перевод не является официальным, мы не гарантируем что он на 100% аккуратен и соответствует [официальной документации на английском языке](https://www.tensorflow.org/?hl=en). Если у вас есть предложение как исправить этот перевод, мы будем очень рады увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs) репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим), напишите нам на [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru)."
94 | ]
95 | },
96 | {
97 | "cell_type": "markdown",
98 | "metadata": {
99 | "colab_type": "text",
100 | "id": "Eg62Pmz3o83v"
101 | },
102 | "source": [
103 | "\n",
104 | "В этом уроке мы будем классифицировать обзоры фильмов как *позитивные* или *негативные*, используя текст обзора. Это пример *бинарной* или двуклассовой классификации, важный и широко применяющийся тип задач машинного обучения.\n",
105 | "\n",
106 | "Учебное руководство демонстрирует применение переноса обучения (transfer learning) с использованием TensorFlow Hub и Keras.\n",
107 | "\n",
108 | "Мы будем использовать [набор данных IMDB](https://www.tensorflow.org/api_docs/python/tf/keras/datasets/imdb) содержащий тексты 50,000 обзоров фильмов из [Internet Movie Database](https://www.imdb.com/). Они разделены на 25,000 обзоров для обучения, и 25,000 обзоров для проверки модели. Обучающая и тестовая выборка *сбалансированы*, т.е. содержат одинаковое количество позитивных и негативных обзоров. \n",
109 | "\n",
110 | "Здесь мы будем использовать [tf.keras](https://www.tensorflow.org/guide/keras), высокоуровневый API для построения и обучения моделей в TensorFlow и [TensorFlow Hub](https://www.tensorflow.org/hub), библиотека и платформа для переноса обучения. Для более продвинутого руководства по классификации текстов с использованием `tf.keras`, см. [Руководство по классификации текстов MLCC](https://developers.google.com/machine-learning/guides/text-classification/)."
111 | ]
112 | },
113 | {
114 | "cell_type": "code",
115 | "metadata": {
116 | "colab_type": "code",
117 | "id": "2ew7HTbPpCJH",
118 | "colab": {}
119 | },
120 | "source": [
121 | "from __future__ import absolute_import, division, print_function, unicode_literals\n",
122 | "\n",
123 | "import numpy as np\n",
124 | "\n",
125 | "try:\n",
126 | " # Colab only\n",
127 | " %tensorflow_version 2.x\n",
128 | "except Exception:\n",
129 | " pass\n",
130 | "import tensorflow as tf\n",
131 | "\n",
132 | "import tensorflow_hub as hub\n",
133 | "import tensorflow_datasets as tfds\n",
134 | "\n",
135 | "print(\"Version: \", tf.__version__)\n",
136 | "print(\"Eager mode: \", tf.executing_eagerly())\n",
137 | "print(\"Hub version: \", hub.__version__)\n",
138 | "print(\"GPU is\", \"available\" if tf.config.experimental.list_physical_devices(\"GPU\") else \"NOT AVAILABLE\")"
139 | ],
140 | "execution_count": 0,
141 | "outputs": []
142 | },
143 | {
144 | "cell_type": "markdown",
145 | "metadata": {
146 | "colab_type": "text",
147 | "id": "iAsKG535pHep"
148 | },
149 | "source": [
150 | "## Скачайте датасет IMDB\n",
151 | "\n",
152 | "Датасет IMDB доступен в [датасетах TensorFlow](https://github.com/tensorflow/datasets). Следующий код скачивает датасет IMDB на ваш компьютер (или в среду выполнения Colab):"
153 | ]
154 | },
155 | {
156 | "cell_type": "code",
157 | "metadata": {
158 | "colab_type": "code",
159 | "id": "zXXx5Oc3pOmN",
160 | "colab": {}
161 | },
162 | "source": [
163 | "# Разобьем обучающую выборку в пропорции 60% на 40%, и у нас будет 15,000 примеров\n",
164 | "# для обучения, 10,000 примеров для валидации и 25,000 примеров для проверки.\n",
165 | "train_validation_split = tfds.Split.TRAIN.subsplit([6, 4])\n",
166 | "\n",
167 | "(train_data, validation_data), test_data = tfds.load(\n",
168 | " name=\"imdb_reviews\", \n",
169 | " split=(train_validation_split, tfds.Split.TEST),\n",
170 | " as_supervised=True)"
171 | ],
172 | "execution_count": 0,
173 | "outputs": []
174 | },
175 | {
176 | "cell_type": "markdown",
177 | "metadata": {
178 | "colab_type": "text",
179 | "id": "l50X3GfjpU4r"
180 | },
181 | "source": [
182 | "## Исследуйте данные \n",
183 | "\n",
184 | "Давайте уделим немного времени, чтобы разобраться в формате данных. Каждый пример представляет собой предложение являющееся обзором фильма и соответствующую метку. Предложение никак не предобработано. Метка является целым числом, 0 или 1, где 0 - это отрицательный отзыв, а 1 - положительный.\n",
185 | "\n",
186 | "Выведем первые 10 примеров."
187 | ]
188 | },
189 | {
190 | "cell_type": "code",
191 | "metadata": {
192 | "colab_type": "code",
193 | "id": "QtTS4kpEpjbi",
194 | "colab": {}
195 | },
196 | "source": [
197 | "train_examples_batch, train_labels_batch = next(iter(train_data.batch(10)))\n",
198 | "train_examples_batch"
199 | ],
200 | "execution_count": 0,
201 | "outputs": []
202 | },
203 | {
204 | "cell_type": "markdown",
205 | "metadata": {
206 | "colab_type": "text",
207 | "id": "IFtaCHTdc-GY"
208 | },
209 | "source": [
210 | "Также напечатаем первые 10 меток."
211 | ]
212 | },
213 | {
214 | "cell_type": "code",
215 | "metadata": {
216 | "colab_type": "code",
217 | "id": "tvAjVXOWc6Mj",
218 | "colab": {}
219 | },
220 | "source": [
221 | "train_labels_batch"
222 | ],
223 | "execution_count": 0,
224 | "outputs": []
225 | },
226 | {
227 | "cell_type": "markdown",
228 | "metadata": {
229 | "colab_type": "text",
230 | "id": "LLC02j2g-llC"
231 | },
232 | "source": [
233 | "## Постройте модель\n",
234 | "\n",
235 | "Нейронная сеть создается послойно - это требует три основных архитектурных решения:\n",
236 | "\n",
237 | "* Как представить текст?\n",
238 | "* Сколько слоев использовать в модели?\n",
239 | "* Сколько *скрытых нейронов* использовать в каждом слое?\n",
240 | "\n",
241 | "В этом примере, входные данные состоят из предложений. Метки которые нужно предсказать являются 0 либо 1.\n",
242 | "\n",
243 | "Одним из способов представления текста является преобразование предложений в векторные представления слов. Мы можем использовать предварительно обученное векторное представление текста в качестве первого слоя. Это имеет три преимущества:\n",
244 | "\n",
245 | "* нам не нужно беспокоиться о препроцессинге текста,\n",
246 | "* мы можем извлечь выгоду из переноса обучения,\n",
247 | "* векторное представление фиксированного размера, поэтому его проще обрабатывать.\n",
248 | "\n",
249 | "Для этого примера мы используем **предобученную модель векторного представления текста** из [TensorFlow Hub](https://www.tensorflow.org/hub) называемую [google/tf2-preview/gnews-swivel-20dim/1](https://tfhub.dev/google/tf2-preview/gnews-swivel-20dim/1).\n",
250 | "\n",
251 | "Есть еще три другие предварительно обученных модели подходящие для этого руководства:\n",
252 | "\n",
253 | "* [google/tf2-preview/gnews-swivel-20dim-with-oov/1](https://tfhub.dev/google/tf2-preview/gnews-swivel-20dim-with-oov/1) - аналогичная [google/tf2-preview/gnews-swivel-20dim/1](https://tfhub.dev/google/tf2-preview/gnews-swivel-20dim/1), но с 2.5% словаря конвертированного в OOV buckets. Это может помочь, если словарь задачи и словарь модели не полностью совпадают.\n",
254 | "* [google/tf2-preview/nnlm-en-dim50/1](https://tfhub.dev/google/tf2-preview/nnlm-en-dim50/1) - Намного большая модель с размером словаря ~1M и размерностью вложения 50.\n",
255 | "* [google/tf2-preview/nnlm-en-dim128/1](https://tfhub.dev/google/tf2-preview/nnlm-en-dim128/1) - Еще большая модель с размером словаря ~1M и размерностью вложения 128."
256 | ]
257 | },
258 | {
259 | "cell_type": "markdown",
260 | "metadata": {
261 | "colab_type": "text",
262 | "id": "In2nDpTLkgKa"
263 | },
264 | "source": [
265 | "Давайте сначала создадим слой Keras, который использует модель TensorFlow Hub для векторного представления предложений, и опробуем его на нескольких входных примерах. Обратите внимание, что независимо от длины входного текста, размерность векторного представления будет следующей: `(num_examples, embedding_dimension)`"
266 | ]
267 | },
268 | {
269 | "cell_type": "code",
270 | "metadata": {
271 | "colab_type": "code",
272 | "id": "_NUbzVeYkgcO",
273 | "colab": {}
274 | },
275 | "source": [
276 | "embedding = \"https://tfhub.dev/google/tf2-preview/gnews-swivel-20dim/1\"\n",
277 | "hub_layer = hub.KerasLayer(embedding, input_shape=[], \n",
278 | " dtype=tf.string, trainable=True)\n",
279 | "hub_layer(train_examples_batch[:3])"
280 | ],
281 | "execution_count": 0,
282 | "outputs": []
283 | },
284 | {
285 | "cell_type": "markdown",
286 | "metadata": {
287 | "colab_type": "text",
288 | "id": "dfSbV6igl1EH"
289 | },
290 | "source": [
291 | "Давайте построим полную модель:"
292 | ]
293 | },
294 | {
295 | "cell_type": "code",
296 | "metadata": {
297 | "colab_type": "code",
298 | "id": "xpKOoWgu-llD",
299 | "colab": {}
300 | },
301 | "source": [
302 | "model = tf.keras.Sequential()\n",
303 | "model.add(hub_layer)\n",
304 | "model.add(tf.keras.layers.Dense(16, activation='relu'))\n",
305 | "model.add(tf.keras.layers.Dense(1, activation='sigmoid'))\n",
306 | "\n",
307 | "model.summary()"
308 | ],
309 | "execution_count": 0,
310 | "outputs": []
311 | },
312 | {
313 | "cell_type": "markdown",
314 | "metadata": {
315 | "colab_type": "text",
316 | "id": "6PbKQ6mucuKL"
317 | },
318 | "source": [
319 | "Для построения классификатора зададим слои последовательно:\n",
320 | "\n",
321 | "1. Первый слой это слой TensorFlow Hub. Этот слой использует предобученную Saved Model, отображающую предложения в векторные представления. Предобученная модель векторного представления слов которую мы используем ([google/tf2-preview/gnews-swivel-20dim/1](https://tfhub.dev/google/tf2-preview/gnews-swivel-20dim/1)) разбивает предложение на токены, встраивает каждый токен и затем объединяет вложения. В результате получаются размерности: `(num_examples, embedding_dimension)`.\n",
322 | "2. Получившийся в результате вектор фиксированной длины пропускается сквозь полносвязный (`Dense`) слой состоящий из 16 скрытых нейронов.\n",
323 | "3. Последний слой плотно связан с единственным выходным нейроном. С использованием функции активации `сигмоида`, значение получается между 0 и 1, представляя вероятность или уровень доверия.\n",
324 | "\n",
325 | "Давайте скомпилируем модель."
326 | ]
327 | },
328 | {
329 | "cell_type": "markdown",
330 | "metadata": {
331 | "colab_type": "text",
332 | "id": "L4EqVWg4-llM"
333 | },
334 | "source": [
335 | "### Функция потерь и оптимизатор\n",
336 | "\n",
337 | "Для модели нам необходимо указать функцию потерь и оптимизатор для обучения. Поскольку мы решаем задачу бинарной классификации и на выходе модели будут вероятности (слой из единственного элемента с сигмоидой в качестве функции активации), то мы воспользуемся функцией потерь binary_crossentropy (пер. \"Перекрестная энтропия\").\n",
338 | "\n",
339 | "Это не единственный выбор для функции потерь: Вы можете, например, выбрать `mean_squared_error`. Но обычно `binary_crossentropy` лучше справляется с вероятностями - она измеряет \"дистанцию\" между распределениями вероятностей, или, как в нашем случае, между истинным распределением и предсказаниями.\n",
340 | "\n",
341 | "Далее, когда мы исследуем задачи регрессии (например, предсказание цен на недвижимость), мы посмотрим как использовать другую функцию потерь, которая называется среднеквадратическая ошибка (MSE).\n",
342 | "\n",
343 | "А сейчас настроим модель с использованием оптимизатора и функции потерь:"
344 | ]
345 | },
346 | {
347 | "cell_type": "code",
348 | "metadata": {
349 | "colab_type": "code",
350 | "id": "Mr0GP-cQ-llN",
351 | "colab": {}
352 | },
353 | "source": [
354 | "model.compile(optimizer='adam',\n",
355 | " loss='binary_crossentropy',\n",
356 | " metrics=['accuracy'])"
357 | ],
358 | "execution_count": 0,
359 | "outputs": []
360 | },
361 | {
362 | "cell_type": "markdown",
363 | "metadata": {
364 | "colab_type": "text",
365 | "id": "35jv_fzP-llU"
366 | },
367 | "source": [
368 | "## Обучите модель\n",
369 | "\n",
370 | "Обучите модель за 20 эпох в мини-батчах по 512 образцов. Это 20 итераций по всем образцам данных в тензорах `x_train` и `y_train`. Во время обучениЯ следите за функцией потерь и точностью на 10 000 примеров из проверочного набора данных:"
371 | ]
372 | },
373 | {
374 | "cell_type": "code",
375 | "metadata": {
376 | "colab_type": "code",
377 | "id": "tXSGrjWZ-llW",
378 | "colab": {}
379 | },
380 | "source": [
381 | "history = model.fit(train_data.shuffle(10000).batch(512),\n",
382 | " epochs=20,\n",
383 | " validation_data=validation_data.batch(512),\n",
384 | " verbose=1)"
385 | ],
386 | "execution_count": 0,
387 | "outputs": []
388 | },
389 | {
390 | "cell_type": "markdown",
391 | "metadata": {
392 | "colab_type": "text",
393 | "id": "9EEGuDVuzb5r"
394 | },
395 | "source": [
396 | "## Оцените модель\n",
397 | "\n",
398 | "Давайте посмотрим как работает модель. Она будет возвращать два значения. Потери (число, показывающее нашу ошибку, меньшие значения - лучше) и точность (accuracy)."
399 | ]
400 | },
401 | {
402 | "cell_type": "code",
403 | "metadata": {
404 | "colab_type": "code",
405 | "id": "zOMKywn4zReN",
406 | "colab": {}
407 | },
408 | "source": [
409 | "results = model.evaluate(test_data.batch(512), verbose=2)\n",
410 | "for name, value in zip(model.metrics_names, results):\n",
411 | " print(\"%s: %.3f\" % (name, value))"
412 | ],
413 | "execution_count": 0,
414 | "outputs": []
415 | },
416 | {
417 | "cell_type": "markdown",
418 | "metadata": {
419 | "colab_type": "text",
420 | "id": "z1iEXVTR0Z2t"
421 | },
422 | "source": [
423 | "Этот довольно наивный подход достиг точности около 87%. С более продвинутыми методами модель бы приблизилась к 95%."
424 | ]
425 | },
426 | {
427 | "cell_type": "markdown",
428 | "metadata": {
429 | "colab_type": "text",
430 | "id": "5KggXVeL-llZ"
431 | },
432 | "source": [
433 | "## Для дальнейшего чтения\n",
434 | "\n",
435 | "Для более общего способа работы со строковыми входными данными и более подробного анализа прогресса точности и потерь во время обучения, взгляните [сюда](https://www.tensorflow.org/tutorials/keras/basic_text_classification)."
436 | ]
437 | }
438 | ]
439 | }
440 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/tutorials/load_data/numpy.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "numpy.ipynb",
7 | "version": "0.3.2",
8 | "provenance": [],
9 | "private_outputs": true,
10 | "collapsed_sections": [],
11 | "toc_visible": true
12 | },
13 | "kernelspec": {
14 | "display_name": "Python 3",
15 | "name": "python3"
16 | }
17 | },
18 | "cells": [
19 | {
20 | "cell_type": "markdown",
21 | "metadata": {
22 | "colab_type": "text",
23 | "id": "pixDvex9KBqt"
24 | },
25 | "source": [
26 | "##### Copyright 2019 The TensorFlow Authors."
27 | ]
28 | },
29 | {
30 | "cell_type": "code",
31 | "metadata": {
32 | "cellView": "form",
33 | "colab_type": "code",
34 | "id": "K16pBM8mKK7a",
35 | "colab": {}
36 | },
37 | "source": [
38 | "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
39 | "# you may not use this file except in compliance with the License.\n",
40 | "# You may obtain a copy of the License at\n",
41 | "#\n",
42 | "# https://www.apache.org/licenses/LICENSE-2.0\n",
43 | "#\n",
44 | "# Unless required by applicable law or agreed to in writing, software\n",
45 | "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
46 | "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
47 | "# See the License for the specific language governing permissions and\n",
48 | "# limitations under the License."
49 | ],
50 | "execution_count": 0,
51 | "outputs": []
52 | },
53 | {
54 | "cell_type": "markdown",
55 | "metadata": {
56 | "colab_type": "text",
57 | "id": "TfRdquslKbO3"
58 | },
59 | "source": [
60 | "# Загрузка данных NumPy"
61 | ]
62 | },
63 | {
64 | "cell_type": "markdown",
65 | "metadata": {
66 | "colab_type": "text",
67 | "id": "-uq3F0ggKlZb"
68 | },
69 | "source": [
70 | ""
84 | ]
85 | },
86 | {
87 | "cell_type": "markdown",
88 | "metadata": {
89 | "id": "fj66ZXAzrJC2",
90 | "colab_type": "text"
91 | },
92 | "source": [
93 | "Note: Вся информация в этом разделе переведена с помощью русскоговорящего Tensorflow сообщества на общественных началах. Поскольку этот перевод не является официальным, мы не гарантируем что он на 100% аккуратен и соответствует [официальной документации на английском языке](https://www.tensorflow.org/?hl=en). Если у вас есть предложение как исправить этот перевод, мы будем очень рады увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs) репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим), напишите нам на [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru)."
94 | ]
95 | },
96 | {
97 | "cell_type": "markdown",
98 | "metadata": {
99 | "colab_type": "text",
100 | "id": "-0tqX8qkXZEj"
101 | },
102 | "source": [
103 | "В этом руководстве приведен пример загрузки данных из массивов NumPy в `tf.data.Dataset`.\n",
104 | "\n",
105 | "Этот пример загружает датасет MNIST из файла `.npz`. Однако источник массивов NumPy не важен.\n"
106 | ]
107 | },
108 | {
109 | "cell_type": "markdown",
110 | "metadata": {
111 | "colab_type": "text",
112 | "id": "-Ze5IBx9clLB"
113 | },
114 | "source": [
115 | "## Setup"
116 | ]
117 | },
118 | {
119 | "cell_type": "code",
120 | "metadata": {
121 | "colab_type": "code",
122 | "id": "D1gtCQrnNk6b",
123 | "colab": {}
124 | },
125 | "source": [
126 | "try:\n",
127 | " # %tensorflow_version существует только в Colab.\n",
128 | " %tensorflow_version 2.x\n",
129 | "except Exception:\n",
130 | " pass\n"
131 | ],
132 | "execution_count": 0,
133 | "outputs": []
134 | },
135 | {
136 | "cell_type": "code",
137 | "metadata": {
138 | "colab_type": "code",
139 | "id": "k6J3JzK5NxQ6",
140 | "colab": {}
141 | },
142 | "source": [
143 | "from __future__ import absolute_import, division, print_function, unicode_literals\n",
144 | " \n",
145 | "import numpy as np\n",
146 | "import tensorflow as tf"
147 | ],
148 | "execution_count": 0,
149 | "outputs": []
150 | },
151 | {
152 | "cell_type": "markdown",
153 | "metadata": {
154 | "colab_type": "text",
155 | "id": "G0yWiN8-cpDb"
156 | },
157 | "source": [
158 | "### Load from `.npz` file"
159 | ]
160 | },
161 | {
162 | "cell_type": "code",
163 | "metadata": {
164 | "colab_type": "code",
165 | "id": "GLHNrFM6RWoM",
166 | "colab": {}
167 | },
168 | "source": [
169 | "DATA_URL = 'https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz'\n",
170 | "\n",
171 | "path = tf.keras.utils.get_file('mnist.npz', DATA_URL)\n",
172 | "with np.load(path) as data:\n",
173 | " train_examples = data['x_train']\n",
174 | " train_labels = data['y_train']\n",
175 | " test_examples = data['x_test']\n",
176 | " test_labels = data['y_test']"
177 | ],
178 | "execution_count": 0,
179 | "outputs": []
180 | },
181 | {
182 | "cell_type": "markdown",
183 | "metadata": {
184 | "colab_type": "text",
185 | "id": "cCeCkvrDgCMM"
186 | },
187 | "source": [
188 | "## Загрузите массивы NumPy с `tf.data.Dataset`"
189 | ]
190 | },
191 | {
192 | "cell_type": "markdown",
193 | "metadata": {
194 | "colab_type": "text",
195 | "id": "tslB0tJPgB-2"
196 | },
197 | "source": [
198 | "Представьте что у вас есть массив примеров и соответствующий массив меток, передайте эти два массива кортежом в `tf.data.Dataset.from_tensor_slices` чтобы создать `tf.data.Dataset`."
199 | ]
200 | },
201 | {
202 | "cell_type": "code",
203 | "metadata": {
204 | "colab_type": "code",
205 | "id": "QN_8wwc5R7Qm",
206 | "colab": {}
207 | },
208 | "source": [
209 | "train_dataset = tf.data.Dataset.from_tensor_slices((train_examples, train_labels))\n",
210 | "test_dataset = tf.data.Dataset.from_tensor_slices((test_examples, test_labels))"
211 | ],
212 | "execution_count": 0,
213 | "outputs": []
214 | },
215 | {
216 | "cell_type": "markdown",
217 | "metadata": {
218 | "colab_type": "text",
219 | "id": "6Rco85bbkDfN"
220 | },
221 | "source": [
222 | "## Используйте датасеты"
223 | ]
224 | },
225 | {
226 | "cell_type": "markdown",
227 | "metadata": {
228 | "colab_type": "text",
229 | "id": "0dvl1uUukc4K"
230 | },
231 | "source": [
232 | "### Перемешайте датасеты и разбейте их на пакеты"
233 | ]
234 | },
235 | {
236 | "cell_type": "code",
237 | "metadata": {
238 | "colab_type": "code",
239 | "id": "GTXdRMPcSXZj",
240 | "colab": {}
241 | },
242 | "source": [
243 | "BATCH_SIZE = 64\n",
244 | "SHUFFLE_BUFFER_SIZE = 100\n",
245 | "\n",
246 | "train_dataset = train_dataset.shuffle(SHUFFLE_BUFFER_SIZE).batch(BATCH_SIZE)\n",
247 | "test_dataset = test_dataset.batch(BATCH_SIZE)"
248 | ],
249 | "execution_count": 0,
250 | "outputs": []
251 | },
252 | {
253 | "cell_type": "markdown",
254 | "metadata": {
255 | "colab_type": "text",
256 | "id": "w69Jl8k6lilg"
257 | },
258 | "source": [
259 | "### Постройте и обучите модель"
260 | ]
261 | },
262 | {
263 | "cell_type": "code",
264 | "metadata": {
265 | "colab_type": "code",
266 | "id": "Uhxr8py4DkDN",
267 | "colab": {}
268 | },
269 | "source": [
270 | "model = tf.keras.Sequential([\n",
271 | " tf.keras.layers.Flatten(input_shape=(28, 28)),\n",
272 | " tf.keras.layers.Dense(128, activation='relu'),\n",
273 | " tf.keras.layers.Dense(10, activation='softmax')\n",
274 | "])\n",
275 | "\n",
276 | "model.compile(optimizer=tf.keras.optimizers.RMSprop(),\n",
277 | " loss=tf.keras.losses.SparseCategoricalCrossentropy(),\n",
278 | " metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])"
279 | ],
280 | "execution_count": 0,
281 | "outputs": []
282 | },
283 | {
284 | "cell_type": "code",
285 | "metadata": {
286 | "colab_type": "code",
287 | "id": "XLDzlPGgOHBx",
288 | "colab": {}
289 | },
290 | "source": [
291 | "model.fit(train_dataset, epochs=10)"
292 | ],
293 | "execution_count": 0,
294 | "outputs": []
295 | },
296 | {
297 | "cell_type": "code",
298 | "metadata": {
299 | "colab_type": "code",
300 | "id": "2q82yN8mmKIE",
301 | "colab": {}
302 | },
303 | "source": [
304 | "model.evaluate(test_dataset)"
305 | ],
306 | "execution_count": 0,
307 | "outputs": []
308 | }
309 | ]
310 | }
--------------------------------------------------------------------------------
/docs-r2.1/ru/tutorials/load_data/pandas_dataframe.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "pandas_dataframe.ipynb",
7 | "version": "0.3.2",
8 | "provenance": [],
9 | "private_outputs": true,
10 | "collapsed_sections": [],
11 | "toc_visible": true
12 | },
13 | "kernelspec": {
14 | "display_name": "Python 3",
15 | "name": "python3"
16 | }
17 | },
18 | "cells": [
19 | {
20 | "cell_type": "markdown",
21 | "metadata": {
22 | "colab_type": "text",
23 | "id": "zwBCE43Cv3PH"
24 | },
25 | "source": [
26 | "##### Copyright 2019 The TensorFlow Authors.\n",
27 | "\n",
28 | "Licensed under the Apache License, Version 2.0 (the \"License\");"
29 | ]
30 | },
31 | {
32 | "cell_type": "code",
33 | "metadata": {
34 | "cellView": "form",
35 | "colab_type": "code",
36 | "id": "fOad0I2cv569",
37 | "colab": {}
38 | },
39 | "source": [
40 | "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
41 | "# you may not use this file except in compliance with the License.\n",
42 | "# You may obtain a copy of the License at\n",
43 | "#\n",
44 | "# https://www.apache.org/licenses/LICENSE-2.0\n",
45 | "#\n",
46 | "# Unless required by applicable law or agreed to in writing, software\n",
47 | "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
48 | "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
49 | "# See the License for the specific language governing permissions and\n",
50 | "# limitations under the License."
51 | ],
52 | "execution_count": 0,
53 | "outputs": []
54 | },
55 | {
56 | "cell_type": "markdown",
57 | "metadata": {
58 | "colab_type": "text",
59 | "id": "YQB7yiF6v9GR"
60 | },
61 | "source": [
62 | "# Загрузка pandas.DataFrame"
63 | ]
64 | },
65 | {
66 | "cell_type": "markdown",
67 | "metadata": {
68 | "colab_type": "text",
69 | "id": "Oqa952X4wQKK"
70 | },
71 | "source": [
72 | ""
86 | ]
87 | },
88 | {
89 | "cell_type": "markdown",
90 | "metadata": {
91 | "id": "fj66ZXAzrJC2",
92 | "colab_type": "text"
93 | },
94 | "source": [
95 | "Note: Вся информация в этом разделе переведена с помощью русскоговорящего Tensorflow сообщества на общественных началах. Поскольку этот перевод не является официальным, мы не гарантируем что он на 100% аккуратен и соответствует [официальной документации на английском языке](https://www.tensorflow.org/?hl=en). Если у вас есть предложение как исправить этот перевод, мы будем очень рады увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs) репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим), напишите нам на [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru)."
96 | ]
97 | },
98 | {
99 | "cell_type": "markdown",
100 | "metadata": {
101 | "colab_type": "text",
102 | "id": "UmyEaf4Awl2v"
103 | },
104 | "source": [
105 | "Из этого руководства вы узнаете, как загрузить датафрейм Pandas в `tf.data.Dataset`.\n",
106 | "\n",
107 | "Это руководство использует небольшой [датасет](https://archive.ics.uci.edu/ml/datasets/heart+Disease) предоставленный Фондом сердечных заболеваний кливлендской клиники. В ней несколько сотен строк в формате CSV. Каждая строка описывает пациента, а каждый столбец описывает свойство. Мы используем эту информацию чтобы предсказать имеет ли пациент сердечное заболевание, что в этом датасете является задачей двоичной классификации."
108 | ]
109 | },
110 | {
111 | "cell_type": "markdown",
112 | "metadata": {
113 | "colab_type": "text",
114 | "id": "iiyC7HkqxlUD"
115 | },
116 | "source": [
117 | "## Прочитайте данные используя pandas"
118 | ]
119 | },
120 | {
121 | "cell_type": "code",
122 | "metadata": {
123 | "colab_type": "code",
124 | "id": "5IoRbCA2n0_V",
125 | "colab": {}
126 | },
127 | "source": [
128 | "from __future__ import absolute_import, division, print_function, unicode_literals\n",
129 | "\n",
130 | "try:\n",
131 | " # %tensorflow_version существует только в Colab.\n",
132 | " %tensorflow_version 2.x\n",
133 | "except Exception:\n",
134 | " pass\n",
135 | "import pandas as pd\n",
136 | "import tensorflow as tf"
137 | ],
138 | "execution_count": 0,
139 | "outputs": []
140 | },
141 | {
142 | "cell_type": "markdown",
143 | "metadata": {
144 | "colab_type": "text",
145 | "id": "-2kBGy_pxn47"
146 | },
147 | "source": [
148 | "Скачайте файл csv содержащий датасет с пациентами."
149 | ]
150 | },
151 | {
152 | "cell_type": "code",
153 | "metadata": {
154 | "colab_type": "code",
155 | "id": "VS4w2LePn9g3",
156 | "colab": {}
157 | },
158 | "source": [
159 | "csv_file = tf.keras.utils.get_file('heart.csv', 'https://storage.googleapis.com/applied-dl/heart.csv')"
160 | ],
161 | "execution_count": 0,
162 | "outputs": []
163 | },
164 | {
165 | "cell_type": "markdown",
166 | "metadata": {
167 | "colab_type": "text",
168 | "id": "6BXRPD2-xtQ1"
169 | },
170 | "source": [
171 | "Прочитайте csv файл используя pandas."
172 | ]
173 | },
174 | {
175 | "cell_type": "code",
176 | "metadata": {
177 | "colab_type": "code",
178 | "id": "UEfJ8TcMpe-2",
179 | "colab": {}
180 | },
181 | "source": [
182 | "df = pd.read_csv(csv_file)"
183 | ],
184 | "execution_count": 0,
185 | "outputs": []
186 | },
187 | {
188 | "cell_type": "code",
189 | "metadata": {
190 | "colab_type": "code",
191 | "id": "8FkK6QIRpjd4",
192 | "colab": {}
193 | },
194 | "source": [
195 | "df.head()"
196 | ],
197 | "execution_count": 0,
198 | "outputs": []
199 | },
200 | {
201 | "cell_type": "code",
202 | "metadata": {
203 | "colab_type": "code",
204 | "id": "_MOAKz654CT5",
205 | "colab": {}
206 | },
207 | "source": [
208 | "df.dtypes"
209 | ],
210 | "execution_count": 0,
211 | "outputs": []
212 | },
213 | {
214 | "cell_type": "markdown",
215 | "metadata": {
216 | "colab_type": "text",
217 | "id": "ww4lRDCS3qPh"
218 | },
219 | "source": [
220 | "Конвертируйте столбец `thal` являющийся `object` в датафрейме в дискретные числовые значения."
221 | ]
222 | },
223 | {
224 | "cell_type": "code",
225 | "metadata": {
226 | "colab_type": "code",
227 | "id": "LmCl5R5C2IKo",
228 | "colab": {}
229 | },
230 | "source": [
231 | "df['thal'] = pd.Categorical(df['thal'])\n",
232 | "df['thal'] = df.thal.cat.codes"
233 | ],
234 | "execution_count": 0,
235 | "outputs": []
236 | },
237 | {
238 | "cell_type": "code",
239 | "metadata": {
240 | "colab_type": "code",
241 | "id": "s4XA1SNW2QyI",
242 | "colab": {}
243 | },
244 | "source": [
245 | "df.head()"
246 | ],
247 | "execution_count": 0,
248 | "outputs": []
249 | },
250 | {
251 | "cell_type": "markdown",
252 | "metadata": {
253 | "colab_type": "text",
254 | "id": "WWRhH6r4xxQu"
255 | },
256 | "source": [
257 | "## Загрузите данные используя `tf.data.Dataset`"
258 | ]
259 | },
260 | {
261 | "cell_type": "markdown",
262 | "metadata": {
263 | "colab_type": "text",
264 | "id": "GuqmVVH_yApQ"
265 | },
266 | "source": [
267 | "Используйте `tf.data.Dataset.from_tensor_slices` чтобы прочитать значения из датафрейма pandas. \n",
268 | "\n",
269 | "Одним из преимуществ использования `tf.data.Dataset` является то, что он позволяет вам писать простые высокоэффективные конвейеры данных. Прочитайте [руководство по загрузке данных](https://www.tensorflow.org/guide/data) для подробностей."
270 | ]
271 | },
272 | {
273 | "cell_type": "code",
274 | "metadata": {
275 | "colab_type": "code",
276 | "id": "2wwhILm1ycSp",
277 | "colab": {}
278 | },
279 | "source": [
280 | "target = df.pop('target')"
281 | ],
282 | "execution_count": 0,
283 | "outputs": []
284 | },
285 | {
286 | "cell_type": "code",
287 | "metadata": {
288 | "colab_type": "code",
289 | "id": "W6Yc-D3aqyBb",
290 | "colab": {}
291 | },
292 | "source": [
293 | "dataset = tf.data.Dataset.from_tensor_slices((df.values, target.values))"
294 | ],
295 | "execution_count": 0,
296 | "outputs": []
297 | },
298 | {
299 | "cell_type": "code",
300 | "metadata": {
301 | "colab_type": "code",
302 | "id": "chEnp_Swsf0a",
303 | "colab": {}
304 | },
305 | "source": [
306 | "for feat, targ in dataset.take(5):\n",
307 | " print ('Признаки: {}, Цель: {}'.format(feat, targ))"
308 | ],
309 | "execution_count": 0,
310 | "outputs": []
311 | },
312 | {
313 | "cell_type": "markdown",
314 | "metadata": {
315 | "colab_type": "text",
316 | "id": "GzwlAhX6xH9Q"
317 | },
318 | "source": [
319 | "Поскольку `pd.Series` реализует протокол `__array__` он может быть использован практически везде где вы бы использовали `np.array` или `tf.Tensor`."
320 | ]
321 | },
322 | {
323 | "cell_type": "code",
324 | "metadata": {
325 | "colab_type": "code",
326 | "id": "GnpHHkpktl5y",
327 | "colab": {}
328 | },
329 | "source": [
330 | "tf.constant(df['thal'])"
331 | ],
332 | "execution_count": 0,
333 | "outputs": []
334 | },
335 | {
336 | "cell_type": "markdown",
337 | "metadata": {
338 | "colab_type": "text",
339 | "id": "9XLxRHS10Ylp"
340 | },
341 | "source": [
342 | "Перемешайте датасет и разбейте его на пакеты."
343 | ]
344 | },
345 | {
346 | "cell_type": "code",
347 | "metadata": {
348 | "colab_type": "code",
349 | "id": "R3dQ-83Ztsgl",
350 | "colab": {}
351 | },
352 | "source": [
353 | "train_dataset = dataset.shuffle(len(df)).batch(1)"
354 | ],
355 | "execution_count": 0,
356 | "outputs": []
357 | },
358 | {
359 | "cell_type": "markdown",
360 | "metadata": {
361 | "colab_type": "text",
362 | "id": "bB9C0XJkyQEk"
363 | },
364 | "source": [
365 | "## Создайте и обучите модель"
366 | ]
367 | },
368 | {
369 | "cell_type": "markdown",
370 | "metadata": {
371 | "colab_type": "text",
372 | "id": "hvFUYZr7OLcL"
373 | },
374 | "source": [
375 | ""
376 | ]
377 | },
378 | {
379 | "cell_type": "code",
380 | "metadata": {
381 | "colab_type": "code",
382 | "id": "FQd9PcPRpkP4",
383 | "colab": {}
384 | },
385 | "source": [
386 | "def get_compiled_model():\n",
387 | " model = tf.keras.Sequential([\n",
388 | " tf.keras.layers.Dense(10, activation='relu'),\n",
389 | " tf.keras.layers.Dense(10, activation='relu'),\n",
390 | " tf.keras.layers.Dense(1, activation='sigmoid')\n",
391 | " ])\n",
392 | "\n",
393 | " model.compile(optimizer='adam',\n",
394 | " loss='binary_crossentropy',\n",
395 | " metrics=['accuracy'])\n",
396 | " return model"
397 | ],
398 | "execution_count": 0,
399 | "outputs": []
400 | },
401 | {
402 | "cell_type": "code",
403 | "metadata": {
404 | "colab_type": "code",
405 | "id": "ybDzNUheqxJw",
406 | "colab": {}
407 | },
408 | "source": [
409 | "model = get_compiled_model()\n",
410 | "model.fit(train_dataset, epochs=15)"
411 | ],
412 | "execution_count": 0,
413 | "outputs": []
414 | },
415 | {
416 | "cell_type": "markdown",
417 | "metadata": {
418 | "colab_type": "text",
419 | "id": "d6V_6F_MBiG9"
420 | },
421 | "source": [
422 | "## Альтернатива столбцам признаков"
423 | ]
424 | },
425 | {
426 | "cell_type": "markdown",
427 | "metadata": {
428 | "colab_type": "text",
429 | "id": "X63B9vDsD8Ly"
430 | },
431 | "source": [
432 | "Передать словарь в качестве входных данных для модели так же просто, как и создать словарь соответствия слоев `tf.keras.layers.Input`, применяя любой препроцессинг и складывая их, используя [функциональный api](../../guide/keras/functional.ipynb). Вы можете использовать это в качестве альтернативы [столбцов признаков](../keras/feature_columns.ipynb)."
433 | ]
434 | },
435 | {
436 | "cell_type": "code",
437 | "metadata": {
438 | "colab_type": "code",
439 | "id": "FwQ47_WmOBnY",
440 | "colab": {}
441 | },
442 | "source": [
443 | "inputs = {key: tf.keras.layers.Input(shape=(), name=key) for key in df.keys()}\n",
444 | "x = tf.stack(list(inputs.values()), axis=-1)\n",
445 | "\n",
446 | "x = tf.keras.layers.Dense(10, activation='relu')(x)\n",
447 | "output = tf.keras.layers.Dense(1, activation='sigmoid')(x)\n",
448 | "\n",
449 | "model_func = tf.keras.Model(inputs=inputs, outputs=output)\n",
450 | "\n",
451 | "model_func.compile(optimizer='adam',\n",
452 | " loss='binary_crossentropy',\n",
453 | " metrics=['accuracy'])"
454 | ],
455 | "execution_count": 0,
456 | "outputs": []
457 | },
458 | {
459 | "cell_type": "markdown",
460 | "metadata": {
461 | "colab_type": "text",
462 | "id": "qSCN5f_vUURE"
463 | },
464 | "source": [
465 | "Простейший способ сохранения структуры столбцов в `pd.DataFrame` при использовании с `tf.data` это конвертация `pd.DataFrame` в `dict` и сделав срезы этого словаря."
466 | ]
467 | },
468 | {
469 | "cell_type": "code",
470 | "metadata": {
471 | "colab_type": "code",
472 | "id": "wUjRKgEhPZqK",
473 | "colab": {}
474 | },
475 | "source": [
476 | "dict_slices = tf.data.Dataset.from_tensor_slices((df.to_dict('list'), target.values)).batch(16)"
477 | ],
478 | "execution_count": 0,
479 | "outputs": []
480 | },
481 | {
482 | "cell_type": "code",
483 | "metadata": {
484 | "colab_type": "code",
485 | "id": "WWRaiwxeyA9Z",
486 | "colab": {}
487 | },
488 | "source": [
489 | "for dict_slice in dict_slices.take(1):\n",
490 | " print (dict_slice)"
491 | ],
492 | "execution_count": 0,
493 | "outputs": []
494 | },
495 | {
496 | "cell_type": "code",
497 | "metadata": {
498 | "colab_type": "code",
499 | "id": "8nTrfczNyKup",
500 | "colab": {}
501 | },
502 | "source": [
503 | "model_func.fit(dict_slices, epochs=15)"
504 | ],
505 | "execution_count": 0,
506 | "outputs": []
507 | }
508 | ]
509 | }
--------------------------------------------------------------------------------
/docs-r2.1/ru/tutorials/load_data/text.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "colab_type": "text",
7 | "id": "DweYe9FcbMK_"
8 | },
9 | "source": [
10 | "##### Copyright 2018 The TensorFlow Authors.\n",
11 | "\n"
12 | ]
13 | },
14 | {
15 | "cell_type": "code",
16 | "execution_count": 0,
17 | "metadata": {
18 | "cellView": "form",
19 | "colab": {},
20 | "colab_type": "code",
21 | "id": "AVV2e0XKbJeX"
22 | },
23 | "outputs": [],
24 | "source": [
25 | "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
26 | "# you may not use this file except in compliance with the License.\n",
27 | "# You may obtain a copy of the License at\n",
28 | "#\n",
29 | "# https://www.apache.org/licenses/LICENSE-2.0\n",
30 | "#\n",
31 | "# Unless required by applicable law or agreed to in writing, software\n",
32 | "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
33 | "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
34 | "# See the License for the specific language governing permissions and\n",
35 | "# limitations under the License."
36 | ]
37 | },
38 | {
39 | "cell_type": "markdown",
40 | "metadata": {
41 | "colab_type": "text",
42 | "id": "sUtoed20cRJJ"
43 | },
44 | "source": [
45 | "# Загрузка текста"
46 | ]
47 | },
48 | {
49 | "cell_type": "markdown",
50 | "metadata": {
51 | "colab_type": "text",
52 | "id": "1ap_W4aQcgNT"
53 | },
54 | "source": [
55 | "\u003ctable class=\"tfo-notebook-buttons\" align=\"left\"\u003e\n",
56 | " \u003ctd\u003e\n",
57 | " \u003ca target=\"_blank\" href=\"https://www.tensorflow.org/tutorials/load_data/text\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" /\u003eСмотрите на TensorFlow.org\u003c/a\u003e\n",
58 | " \u003c/td\u003e\n",
59 | " \u003ctd\u003e\n",
60 | " \u003ca target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs/blob/master/site/ru/tutorials/load_data/text.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /\u003eЗапустите в Google Colab\u003c/a\u003e\n",
61 | " \u003c/td\u003e\n",
62 | " \u003ctd\u003e\n",
63 | " \u003ca target=\"_blank\" href=\"https://github.com/tensorflow/docs/blob/master/site/ru/tutorials/load_data/text.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /\u003eИзучайте код на GitHub\u003c/a\u003e\n",
64 | " \u003c/td\u003e\n",
65 | " \u003ctd\u003e\n",
66 | " \u003ca href=\"https://storage.googleapis.com/tensorflow_docs/docs/site/ru/tutorials/load_data/text.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/download_logo_32px.png\" /\u003eСкачайте ноутбук\u003c/a\u003e\n",
67 | " \u003c/td\u003e\n",
68 | "\u003c/table\u003e"
69 | ]
70 | },
71 | {
72 | "cell_type": "markdown",
73 | "metadata": {
74 | "colab_type": "text",
75 | "id": "fj66ZXAzrJC2"
76 | },
77 | "source": [
78 | "Note: Вся информация в этом разделе переведена с помощью русскоговорящего Tensorflow сообщества на общественных началах. Поскольку этот перевод не является официальным, мы не гарантируем что он на 100% аккуратен и соответствует [официальной документации на английском языке](https://www.tensorflow.org/?hl=en). Если у вас есть предложение как исправить этот перевод, мы будем очень рады увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs) репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим), напишите нам на [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru)."
79 | ]
80 | },
81 | {
82 | "cell_type": "markdown",
83 | "metadata": {
84 | "colab_type": "text",
85 | "id": "NWeQAo0Ec_BL"
86 | },
87 | "source": [
88 | "Это руководство предлагает пример того как использовать `tf.data.TextLineDataset` для загрузки примеров из текстовых файлов. `TextLineDataset` предназначен для создания набора данных из текстового файла, в которых каждый пример это строка текста в исходном файле. Это потенциально полезно для любой текстовых данных которые изначально строковые (например, поэзия или логи ошибок).\n",
89 | "\n",
90 | "В этом руководстве мы будем использовать три разных английских перевода одного и того же текста - \"Илиады\" Гомера, и обучим модель определять переводчика на основе одной строки из текста."
91 | ]
92 | },
93 | {
94 | "cell_type": "markdown",
95 | "metadata": {
96 | "colab_type": "text",
97 | "id": "fgZ9gjmPfSnK"
98 | },
99 | "source": [
100 | "## Установка"
101 | ]
102 | },
103 | {
104 | "cell_type": "code",
105 | "execution_count": 0,
106 | "metadata": {
107 | "colab": {},
108 | "colab_type": "code",
109 | "id": "baYFZMW_bJHh"
110 | },
111 | "outputs": [],
112 | "source": [
113 | "from __future__ import absolute_import, division, print_function, unicode_literals\n",
114 | "\n",
115 | "try:\n",
116 | " # %tensorflow_version существует только в Colab.\n",
117 | " !pip install tf-nightly\n",
118 | "except Exception:\n",
119 | " pass\n",
120 | "import tensorflow as tf\n",
121 | "\n",
122 | "import tensorflow_datasets as tfds\n",
123 | "import os"
124 | ]
125 | },
126 | {
127 | "cell_type": "markdown",
128 | "metadata": {
129 | "colab_type": "text",
130 | "id": "YWVWjyIkffau"
131 | },
132 | "source": [
133 | "Тексты трех переводов выполнили:\n",
134 | "\n",
135 | " - [Вильям Купер](https://en.wikipedia.org/wiki/William_Cowper) — [текст](https://storage.googleapis.com/download.tensorflow.org/data/illiad/cowper.txt)\n",
136 | "\n",
137 | " - [Эрл Эдвард](https://en.wikipedia.org/wiki/Edward_Smith-Stanley,_14th_Earl_of_Derby) — [текст](https://storage.googleapis.com/download.tensorflow.org/data/illiad/derby.txt)\n",
138 | "\n",
139 | "- [Сэмюель Батлер](https://en.wikipedia.org/wiki/Samuel_Butler_%28novelist%29) — [текст](https://storage.googleapis.com/download.tensorflow.org/data/illiad/butler.txt)\n",
140 | "\n",
141 | "Текстовые файлы использованные в этом руководстве были подвергнуты некоторым типичным задачам предварительной обработки, в основном удаление материала - шапка и футер документа, нумерация строк, заголовки глав. Скачайте эти файлы локально."
142 | ]
143 | },
144 | {
145 | "cell_type": "code",
146 | "execution_count": 0,
147 | "metadata": {
148 | "colab": {},
149 | "colab_type": "code",
150 | "id": "4YlKQthEYlFw"
151 | },
152 | "outputs": [],
153 | "source": [
154 | "DIRECTORY_URL = 'https://storage.googleapis.com/download.tensorflow.org/data/illiad/'\n",
155 | "FILE_NAMES = ['cowper.txt', 'derby.txt', 'butler.txt']\n",
156 | "\n",
157 | "for name in FILE_NAMES:\n",
158 | " text_dir = tf.keras.utils.get_file(name, origin=DIRECTORY_URL+name)\n",
159 | " \n",
160 | "parent_dir = os.path.dirname(text_dir)\n",
161 | "\n",
162 | "parent_dir"
163 | ]
164 | },
165 | {
166 | "cell_type": "markdown",
167 | "metadata": {
168 | "colab_type": "text",
169 | "id": "q3sDy6nuXoNp"
170 | },
171 | "source": [
172 | "## Загрузите текст в датасеты\n",
173 | "\n",
174 | "Переберите файлы, загружая каждый в свой датасет.\n",
175 | "\n",
176 | "Каждый пример нужно пометить индивидуально, так что используйте `tf.data.Dataset.map` чтобы применить функцию расставляющую метки каждому элементу. Она переберет каждую запись в датасете возвращая пару (`example, label`)."
177 | ]
178 | },
179 | {
180 | "cell_type": "code",
181 | "execution_count": 0,
182 | "metadata": {
183 | "colab": {},
184 | "colab_type": "code",
185 | "id": "K0BjCOpOh7Ch"
186 | },
187 | "outputs": [],
188 | "source": [
189 | "def labeler(example, index):\n",
190 | " return example, tf.cast(index, tf.int64) \n",
191 | "\n",
192 | "labeled_data_sets = []\n",
193 | "\n",
194 | "for i, file_name in enumerate(FILE_NAMES):\n",
195 | " lines_dataset = tf.data.TextLineDataset(os.path.join(parent_dir, file_name))\n",
196 | " labeled_dataset = lines_dataset.map(lambda ex: labeler(ex, i))\n",
197 | " labeled_data_sets.append(labeled_dataset)"
198 | ]
199 | },
200 | {
201 | "cell_type": "markdown",
202 | "metadata": {
203 | "colab_type": "text",
204 | "id": "M8PHK5J_cXE5"
205 | },
206 | "source": [
207 | "Объедините эти размеченные наборы данных в один и перемешайте его.\n"
208 | ]
209 | },
210 | {
211 | "cell_type": "code",
212 | "execution_count": 0,
213 | "metadata": {
214 | "colab": {},
215 | "colab_type": "code",
216 | "id": "6jAeYkTIi9-2"
217 | },
218 | "outputs": [],
219 | "source": [
220 | "BUFFER_SIZE = 50000\n",
221 | "BATCH_SIZE = 64\n",
222 | "TAKE_SIZE = 5000"
223 | ]
224 | },
225 | {
226 | "cell_type": "code",
227 | "execution_count": 0,
228 | "metadata": {
229 | "colab": {},
230 | "colab_type": "code",
231 | "id": "Qd544E-Sh63L"
232 | },
233 | "outputs": [],
234 | "source": [
235 | "all_labeled_data = labeled_data_sets[0]\n",
236 | "for labeled_dataset in labeled_data_sets[1:]:\n",
237 | " all_labeled_data = all_labeled_data.concatenate(labeled_dataset)\n",
238 | " \n",
239 | "all_labeled_data = all_labeled_data.shuffle(\n",
240 | " BUFFER_SIZE, reshuffle_each_iteration=False)"
241 | ]
242 | },
243 | {
244 | "cell_type": "markdown",
245 | "metadata": {
246 | "colab_type": "text",
247 | "id": "r4JEHrJXeG5k"
248 | },
249 | "source": [
250 | "Вы можете использовать `tf.data.Dataset.take` и `print`, чтобы посмотреть как выглядят пары `(example, label)`. Свойство `numpy` показывает каждое значение тензора."
251 | ]
252 | },
253 | {
254 | "cell_type": "code",
255 | "execution_count": 0,
256 | "metadata": {
257 | "colab": {},
258 | "colab_type": "code",
259 | "id": "gywKlN0xh6u5"
260 | },
261 | "outputs": [],
262 | "source": [
263 | "for ex in all_labeled_data.take(5):\n",
264 | " print(ex)"
265 | ]
266 | },
267 | {
268 | "cell_type": "markdown",
269 | "metadata": {
270 | "colab_type": "text",
271 | "id": "5rrpU2_sfDh0"
272 | },
273 | "source": [
274 | "## Закодируйте текстовые строки числами\n",
275 | "\n",
276 | "Модели машинного обучения работают с числами, не словами, так что строковые значения необходимо конвертировать в списки с числами. Чтобы сделать это поставьте в соответствие каждому слову свое число.\n",
277 | "\n",
278 | "### Создайте словарь\n",
279 | "\n",
280 | "Сперва создайте словарь токенизировав текст в коллекцию отдельных отличающихся слов. Есть несколько способов сделать это и в TensorFlow и в Python. В этом учебнике:\n",
281 | "\n",
282 | "1. Переберите `numpy` значения всех примеров.\n",
283 | "2. Используйте `tfds.features.text.Tokenizer` чтобы разбить их на токены.\n",
284 | "3. Соберите эти токены в множество Python чтобы избавиться от дубликатов\n",
285 | "4. Получите размер словаря для последующего использования."
286 | ]
287 | },
288 | {
289 | "cell_type": "code",
290 | "execution_count": 0,
291 | "metadata": {
292 | "colab": {},
293 | "colab_type": "code",
294 | "id": "YkHtbGnDh6mg"
295 | },
296 | "outputs": [],
297 | "source": [
298 | "tokenizer = tfds.features.text.Tokenizer()\n",
299 | "\n",
300 | "vocabulary_set = set()\n",
301 | "for text_tensor, _ in all_labeled_data:\n",
302 | " some_tokens = tokenizer.tokenize(text_tensor.numpy())\n",
303 | " vocabulary_set.update(some_tokens)\n",
304 | "\n",
305 | "vocab_size = len(vocabulary_set)\n",
306 | "vocab_size"
307 | ]
308 | },
309 | {
310 | "cell_type": "markdown",
311 | "metadata": {
312 | "colab_type": "text",
313 | "id": "0W35VJqAh9zs"
314 | },
315 | "source": [
316 | "### Закодируйте примеры\n",
317 | "\n",
318 | "Создайте кодировщик передав `vocabulary_set` в `tfds.features.text.TokenTextEncoder`. Метод `encode` кодировщика берет строку текста и возвращает список чисел."
319 | ]
320 | },
321 | {
322 | "cell_type": "code",
323 | "execution_count": 0,
324 | "metadata": {
325 | "colab": {},
326 | "colab_type": "code",
327 | "id": "gkxJIVAth6j0"
328 | },
329 | "outputs": [],
330 | "source": [
331 | "encoder = tfds.features.text.TokenTextEncoder(vocabulary_set)"
332 | ]
333 | },
334 | {
335 | "cell_type": "markdown",
336 | "metadata": {
337 | "colab_type": "text",
338 | "id": "v6S5Qyabi-vo"
339 | },
340 | "source": [
341 | "Вы можете посмотреть одну строку чтобы увидеть как выглядит результат работы кодировщика."
342 | ]
343 | },
344 | {
345 | "cell_type": "code",
346 | "execution_count": 0,
347 | "metadata": {
348 | "colab": {},
349 | "colab_type": "code",
350 | "id": "jgxPZaxUuTbk"
351 | },
352 | "outputs": [],
353 | "source": [
354 | "example_text = next(iter(all_labeled_data))[0].numpy()\n",
355 | "print(example_text)"
356 | ]
357 | },
358 | {
359 | "cell_type": "code",
360 | "execution_count": 0,
361 | "metadata": {
362 | "colab": {},
363 | "colab_type": "code",
364 | "id": "XoVpKR3qj5yb"
365 | },
366 | "outputs": [],
367 | "source": [
368 | "encoded_example = encoder.encode(example_text)\n",
369 | "print(encoded_example)"
370 | ]
371 | },
372 | {
373 | "cell_type": "markdown",
374 | "metadata": {
375 | "colab_type": "text",
376 | "id": "p9qHM0v8k_Mg"
377 | },
378 | "source": [
379 | "Теперь запустите кодировщик на датасете обернув его в `tf.py_function` и передав в метод `map` датасета."
380 | ]
381 | },
382 | {
383 | "cell_type": "code",
384 | "execution_count": 0,
385 | "metadata": {
386 | "colab": {},
387 | "colab_type": "code",
388 | "id": "HcIQ7LOTh6eT"
389 | },
390 | "outputs": [],
391 | "source": [
392 | "def encode(text_tensor, label):\n",
393 | " encoded_text = encoder.encode(text_tensor.numpy())\n",
394 | " return encoded_text, label\n",
395 | "\n",
396 | "def encode_map_fn(text, label):\n",
397 | " # py_func doesn't set the shape of the returned tensors.\n",
398 | " encoded_text, label = tf.py_function(encode, \n",
399 | " inp=[text, label], \n",
400 | " Tout=(tf.int64, tf.int64))\n",
401 | "\n",
402 | " # `tf.data.Datasets` work best if all components have a shape set\n",
403 | " # so set the shapes manually: \n",
404 | " encoded_text.set_shape([None])\n",
405 | " label.set_shape([])\n",
406 | "\n",
407 | " return encoded_text, label\n",
408 | "\n",
409 | "\n",
410 | "all_encoded_data = all_labeled_data.map(encode_map_fn)"
411 | ]
412 | },
413 | {
414 | "cell_type": "markdown",
415 | "metadata": {
416 | "colab_type": "text",
417 | "id": "_YZToSXSm0qr"
418 | },
419 | "source": [
420 | "## Разбейте датасет на тестовую и обучающую выборки\n",
421 | "\n",
422 | "Используйте `tf.data.Dataset.take` и `tf.data.Dataset.skip` чтобы создать небольшой тестовый и большой обучающий датасеты.\n",
423 | "\n",
424 | "Перед передачей в модель датасет должны быть разбиты на пакеты. Обычно количество записей в пакете и их размерность должно быть одинаковые."
425 | ]
426 | },
427 | {
428 | "cell_type": "code",
429 | "execution_count": 0,
430 | "metadata": {
431 | "colab": {},
432 | "colab_type": "code",
433 | "id": "r-rmbijQh6bf"
434 | },
435 | "outputs": [],
436 | "source": [
437 | "train_data = all_encoded_data.skip(TAKE_SIZE).shuffle(BUFFER_SIZE)\n",
438 | "train_data = train_data.padded_batch(BATCH_SIZE)\n",
439 | "\n",
440 | "test_data = all_encoded_data.take(TAKE_SIZE)\n",
441 | "test_data = test_data.padded_batch(BATCH_SIZE)"
442 | ]
443 | },
444 | {
445 | "cell_type": "markdown",
446 | "metadata": {
447 | "colab_type": "text",
448 | "id": "Xdz7SVwmqi1l"
449 | },
450 | "source": [
451 | "Сейчас, `test_data` и `train_data` являются не коллекциями пар (`example, label`), а коллекциями пакетов. Каждый пакет это пара вида (*много примеров*, *много меток*) представленная в виде массивов.\n",
452 | "\n",
453 | "Чтобы проиллюстрировать:"
454 | ]
455 | },
456 | {
457 | "cell_type": "code",
458 | "execution_count": 0,
459 | "metadata": {
460 | "colab": {},
461 | "colab_type": "code",
462 | "id": "kMslWfuwoqpB"
463 | },
464 | "outputs": [],
465 | "source": [
466 | "sample_text, sample_labels = next(iter(test_data))\n",
467 | "\n",
468 | "sample_text[0], sample_labels[0]"
469 | ]
470 | },
471 | {
472 | "cell_type": "markdown",
473 | "metadata": {
474 | "colab_type": "text",
475 | "id": "UI4I6_Sa0vWu"
476 | },
477 | "source": [
478 | "Так как мы ввели новую кодировку токенов (нуль использовался для заполнения), размер словаря увеличился на единицу."
479 | ]
480 | },
481 | {
482 | "cell_type": "code",
483 | "execution_count": 0,
484 | "metadata": {
485 | "colab": {},
486 | "colab_type": "code",
487 | "id": "IlD1Lli91vuc"
488 | },
489 | "outputs": [],
490 | "source": [
491 | "vocab_size += 1"
492 | ]
493 | },
494 | {
495 | "cell_type": "markdown",
496 | "metadata": {
497 | "colab_type": "text",
498 | "id": "K8SUhGFNsmRi"
499 | },
500 | "source": [
501 | "## Постройте модель\n",
502 | "\n"
503 | ]
504 | },
505 | {
506 | "cell_type": "code",
507 | "execution_count": 0,
508 | "metadata": {
509 | "colab": {},
510 | "colab_type": "code",
511 | "id": "QJgI1pow2YR9"
512 | },
513 | "outputs": [],
514 | "source": [
515 | "model = tf.keras.Sequential()"
516 | ]
517 | },
518 | {
519 | "cell_type": "markdown",
520 | "metadata": {
521 | "colab_type": "text",
522 | "id": "wi0iiKLTKdoF"
523 | },
524 | "source": [
525 | "Первый слой конвертирует целочисленные представления в плотные векторные вложения. См. руководство [Вложения слов] (../../tutorials/sequences/word_embeddings) для подробностей."
526 | ]
527 | },
528 | {
529 | "cell_type": "code",
530 | "execution_count": 0,
531 | "metadata": {
532 | "colab": {},
533 | "colab_type": "code",
534 | "id": "DR6-ctbY638P"
535 | },
536 | "outputs": [],
537 | "source": [
538 | "model.add(tf.keras.layers.Embedding(vocab_size, 64))"
539 | ]
540 | },
541 | {
542 | "cell_type": "markdown",
543 | "metadata": {
544 | "colab_type": "text",
545 | "id": "_8OJOPohKh1q"
546 | },
547 | "source": [
548 | "Следующий слой является [Long Short-Term Memory](http://colah.github.io/posts/2015-08-Understanding-LSTMs/) слоем, который позволяет моедли понять слова в контексте других слов. Двунаправленная обертка LSTM позволяет ей выучить взаимодействие элементов как с предыдущими так и с последующими элементами."
549 | ]
550 | },
551 | {
552 | "cell_type": "code",
553 | "execution_count": 0,
554 | "metadata": {
555 | "colab": {},
556 | "colab_type": "code",
557 | "id": "x6rnq6DN_WUs"
558 | },
559 | "outputs": [],
560 | "source": [
561 | "model.add(tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64)))"
562 | ]
563 | },
564 | {
565 | "cell_type": "markdown",
566 | "metadata": {
567 | "colab_type": "text",
568 | "id": "cdffbMr5LF1g"
569 | },
570 | "source": [
571 | "И наконец у нас есть серии из одной и более плотно связанных слоев, последний из которых - выходной слой. Выходной слой генерирует вероятность для всех меток. Та у которой большая вероятность и является предсказанием модели для этого примера."
572 | ]
573 | },
574 | {
575 | "cell_type": "code",
576 | "execution_count": 0,
577 | "metadata": {
578 | "colab": {},
579 | "colab_type": "code",
580 | "id": "QTEaNSnLCsv5"
581 | },
582 | "outputs": [],
583 | "source": [
584 | "# Один или более плотных слоев.\n",
585 | "# Отредактируйте список в строке `for` чтобы поэкспериментировать с размером слоев.\n",
586 | "for units in [64, 64]:\n",
587 | " model.add(tf.keras.layers.Dense(units, activation='relu'))\n",
588 | "\n",
589 | "# Выходной слой. Первый аргумент - число меток.\n",
590 | "model.add(tf.keras.layers.Dense(3, activation='softmax'))"
591 | ]
592 | },
593 | {
594 | "cell_type": "markdown",
595 | "metadata": {
596 | "colab_type": "text",
597 | "id": "zLHPU8q5DLi_"
598 | },
599 | "source": [
600 | "Наконец скомпилируйте модель. Для softmax категоризационной модели используйте `sparse_categorical_crossentropy` в виде функции потерь. Вы можете попробовать другие оптимизаторы, но `adam` очень часто используемая."
601 | ]
602 | },
603 | {
604 | "cell_type": "code",
605 | "execution_count": 0,
606 | "metadata": {
607 | "colab": {},
608 | "colab_type": "code",
609 | "id": "pkTBUVO4h6Y5"
610 | },
611 | "outputs": [],
612 | "source": [
613 | "model.compile(optimizer='adam',\n",
614 | " loss='sparse_categorical_crossentropy',\n",
615 | " metrics=['accuracy'])"
616 | ]
617 | },
618 | {
619 | "cell_type": "markdown",
620 | "metadata": {
621 | "colab_type": "text",
622 | "id": "DM-HLo5NDhql"
623 | },
624 | "source": [
625 | "## Обучите модель\n",
626 | "\n",
627 | "Наша модель, работающая на этих данных, дает достойные результаты (около 83%)."
628 | ]
629 | },
630 | {
631 | "cell_type": "code",
632 | "execution_count": 0,
633 | "metadata": {
634 | "colab": {},
635 | "colab_type": "code",
636 | "id": "aLtO33tNh6V8"
637 | },
638 | "outputs": [],
639 | "source": [
640 | "model.fit(train_data, epochs=3, validation_data=test_data)"
641 | ]
642 | },
643 | {
644 | "cell_type": "code",
645 | "execution_count": 0,
646 | "metadata": {
647 | "colab": {},
648 | "colab_type": "code",
649 | "id": "KTPCYf_Jh6TH"
650 | },
651 | "outputs": [],
652 | "source": [
653 | "eval_loss, eval_acc = model.evaluate(test_data)\n",
654 | "\n",
655 | "print('\\nEval loss: {:.3f}, Eval accuracy: {:.3f}'.format(eval_loss, eval_acc))"
656 | ]
657 | }
658 | ],
659 | "metadata": {
660 | "colab": {
661 | "collapsed_sections": [],
662 | "name": "text.ipynb",
663 | "private_outputs": true,
664 | "provenance": [],
665 | "toc_visible": true
666 | },
667 | "kernelspec": {
668 | "display_name": "Python 3",
669 | "name": "python3"
670 | }
671 | },
672 | "nbformat": 4,
673 | "nbformat_minor": 0
674 | }
675 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/tutorials/quickstart/advanced.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "advanced.ipynb",
7 | "version": "0.3.2",
8 | "provenance": [],
9 | "private_outputs": true,
10 | "collapsed_sections": [],
11 | "toc_visible": true
12 | },
13 | "kernelspec": {
14 | "display_name": "Python 3",
15 | "name": "python3"
16 | }
17 | },
18 | "cells": [
19 | {
20 | "cell_type": "markdown",
21 | "metadata": {
22 | "colab_type": "text",
23 | "id": "rX8mhOLljYeM"
24 | },
25 | "source": [
26 | "##### Copyright 2019 The TensorFlow Authors."
27 | ]
28 | },
29 | {
30 | "cell_type": "code",
31 | "metadata": {
32 | "cellView": "form",
33 | "colab_type": "code",
34 | "id": "BZSlp3DAjdYf",
35 | "colab": {}
36 | },
37 | "source": [
38 | "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
39 | "# you may not use this file except in compliance with the License.\n",
40 | "# You may obtain a copy of the License at\n",
41 | "#\n",
42 | "# https://www.apache.org/licenses/LICENSE-2.0\n",
43 | "#\n",
44 | "# Unless required by applicable law or agreed to in writing, software\n",
45 | "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
46 | "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
47 | "# See the License for the specific language governing permissions and\n",
48 | "# limitations under the License."
49 | ],
50 | "execution_count": 0,
51 | "outputs": []
52 | },
53 | {
54 | "cell_type": "markdown",
55 | "metadata": {
56 | "colab_type": "text",
57 | "id": "3wF5wszaj97Y"
58 | },
59 | "source": [
60 | "# Начните с TensorFlow 2.0 для экспертов"
61 | ]
62 | },
63 | {
64 | "cell_type": "markdown",
65 | "metadata": {
66 | "colab_type": "text",
67 | "id": "DUNzJc4jTj6G"
68 | },
69 | "source": [
70 | ""
84 | ]
85 | },
86 | {
87 | "cell_type": "markdown",
88 | "metadata": {
89 | "id": "gVN4BFQ5Dg4v",
90 | "colab_type": "text"
91 | },
92 | "source": [
93 | "Note: Вся информация в этом разделе переведена с помощью русскоговорящего Tensorflow сообщества на общественных началах. Поскольку этот перевод не является официальным, мы не гарантируем что он на 100% аккуратен и соответствует [официальной документации на английском языке](https://www.tensorflow.org/?hl=en). Если у вас есть предложение как исправить этот перевод, мы будем очень рады увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs) репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим), напишите нам на [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru)."
94 | ]
95 | },
96 | {
97 | "cell_type": "markdown",
98 | "metadata": {
99 | "colab_type": "text",
100 | "id": "hiH7AC-NTniF"
101 | },
102 | "source": [
103 | "Это файл [Google Colaboratory](https://colab.research.google.com/notebooks/welcome.ipynb) notebook. Программы Python programs запускающиеся прямо в браузере - хороший способ учить и использовать TensorFlow. Чтобы следовать этому руководству, запустите notebook в Google Colab нажав на соответствующую кнопку вверху этой страницы.\n",
104 | "\n",
105 | "1. В Colab подключитесь к среде исполнения Python: в правом верхнем углу строки меню выберите *CONNECT*.\n",
106 | "2. Запустите код во всех ячейках notebook: Выберите *Runtime* и *Run all*."
107 | ]
108 | },
109 | {
110 | "cell_type": "markdown",
111 | "metadata": {
112 | "id": "eOsVdx6GGHmU",
113 | "colab_type": "text"
114 | },
115 | "source": [
116 | "Скачайте и установите пакет TensorFlow 2.0:"
117 | ]
118 | },
119 | {
120 | "cell_type": "code",
121 | "metadata": {
122 | "id": "ioLbtB3uGKPX",
123 | "colab_type": "code",
124 | "colab": {}
125 | },
126 | "source": [
127 | "try:\n",
128 | " # Colab only\n",
129 | " %tensorflow_version 2.x\n",
130 | "except Exception:\n",
131 | " pass\n"
132 | ],
133 | "execution_count": 0,
134 | "outputs": []
135 | },
136 | {
137 | "cell_type": "markdown",
138 | "metadata": {
139 | "id": "QS7DDTiZGRTo",
140 | "colab_type": "text"
141 | },
142 | "source": [
143 | "Импортируйте TensorFlow в свою программу:"
144 | ]
145 | },
146 | {
147 | "cell_type": "code",
148 | "metadata": {
149 | "colab_type": "code",
150 | "id": "0trJmd6DjqBZ",
151 | "colab": {}
152 | },
153 | "source": [
154 | "from __future__ import absolute_import, division, print_function, unicode_literals\n",
155 | "\n",
156 | "import tensorflow as tf\n",
157 | "\n",
158 | "from tensorflow.keras.layers import Dense, Flatten, Conv2D\n",
159 | "from tensorflow.keras import Model"
160 | ],
161 | "execution_count": 0,
162 | "outputs": []
163 | },
164 | {
165 | "cell_type": "markdown",
166 | "metadata": {
167 | "colab_type": "text",
168 | "id": "7NAbSZiaoJ4z"
169 | },
170 | "source": [
171 | "Загрузите и приготовьте [набор данных MNIST](http://yann.lecun.com/exdb/mnist/)."
172 | ]
173 | },
174 | {
175 | "cell_type": "code",
176 | "metadata": {
177 | "colab_type": "code",
178 | "id": "JqFRS6K07jJs",
179 | "colab": {}
180 | },
181 | "source": [
182 | "mnist = tf.keras.datasets.mnist\n",
183 | "\n",
184 | "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
185 | "x_train, x_test = x_train / 255.0, x_test / 255.0\n",
186 | "\n",
187 | "# Add a channels dimension\n",
188 | "x_train = x_train[..., tf.newaxis]\n",
189 | "x_test = x_test[..., tf.newaxis]"
190 | ],
191 | "execution_count": 0,
192 | "outputs": []
193 | },
194 | {
195 | "cell_type": "markdown",
196 | "metadata": {
197 | "colab_type": "text",
198 | "id": "k1Evqx0S22r_"
199 | },
200 | "source": [
201 | "Используйте `tf.data` чтобы разбить на пакеты и перемешать данные:"
202 | ]
203 | },
204 | {
205 | "cell_type": "code",
206 | "metadata": {
207 | "colab_type": "code",
208 | "id": "8Iu_quO024c2",
209 | "colab": {}
210 | },
211 | "source": [
212 | "train_ds = tf.data.Dataset.from_tensor_slices(\n",
213 | " (x_train, y_train)).shuffle(10000).batch(32)\n",
214 | "test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)"
215 | ],
216 | "execution_count": 0,
217 | "outputs": []
218 | },
219 | {
220 | "cell_type": "markdown",
221 | "metadata": {
222 | "colab_type": "text",
223 | "id": "BPZ68wASog_I"
224 | },
225 | "source": [
226 | "Постройте модель `tf.keras` используя Keras [model subclassing API](https://www.tensorflow.org/guide/keras#model_subclassing):"
227 | ]
228 | },
229 | {
230 | "cell_type": "code",
231 | "metadata": {
232 | "colab_type": "code",
233 | "id": "h3IKyzTCDNGo",
234 | "colab": {}
235 | },
236 | "source": [
237 | "class MyModel(Model):\n",
238 | " def __init__(self):\n",
239 | " super(MyModel, self).__init__()\n",
240 | " self.conv1 = Conv2D(32, 3, activation='relu')\n",
241 | " self.flatten = Flatten()\n",
242 | " self.d1 = Dense(128, activation='relu')\n",
243 | " self.d2 = Dense(10, activation='softmax')\n",
244 | "\n",
245 | " def call(self, x):\n",
246 | " x = self.conv1(x)\n",
247 | " x = self.flatten(x)\n",
248 | " x = self.d1(x)\n",
249 | " return self.d2(x)\n",
250 | "\n",
251 | "model = MyModel()"
252 | ],
253 | "execution_count": 0,
254 | "outputs": []
255 | },
256 | {
257 | "cell_type": "markdown",
258 | "metadata": {
259 | "colab_type": "text",
260 | "id": "uGih-c2LgbJu"
261 | },
262 | "source": [
263 | "Выберите оптимизатор и функцию потерь для обучения: "
264 | ]
265 | },
266 | {
267 | "cell_type": "code",
268 | "metadata": {
269 | "colab_type": "code",
270 | "id": "u48C9WQ774n4",
271 | "colab": {}
272 | },
273 | "source": [
274 | "loss_object = tf.keras.losses.SparseCategoricalCrossentropy()\n",
275 | "\n",
276 | "optimizer = tf.keras.optimizers.Adam()"
277 | ],
278 | "execution_count": 0,
279 | "outputs": []
280 | },
281 | {
282 | "cell_type": "markdown",
283 | "metadata": {
284 | "colab_type": "text",
285 | "id": "JB6A1vcigsIe"
286 | },
287 | "source": [
288 | "Выберите метрики для измерения потерь и доли правильных ответов (accuracy) модели. Эти метрики аккумулируют значения за эпохи и потом выводят общий результат."
289 | ]
290 | },
291 | {
292 | "cell_type": "code",
293 | "metadata": {
294 | "colab_type": "code",
295 | "id": "N0MqHFb4F_qn",
296 | "colab": {}
297 | },
298 | "source": [
299 | "train_loss = tf.keras.metrics.Mean(name='train_loss')\n",
300 | "train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')\n",
301 | "\n",
302 | "test_loss = tf.keras.metrics.Mean(name='test_loss')\n",
303 | "test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')"
304 | ],
305 | "execution_count": 0,
306 | "outputs": []
307 | },
308 | {
309 | "cell_type": "markdown",
310 | "metadata": {
311 | "colab_type": "text",
312 | "id": "ix4mEL65on-w"
313 | },
314 | "source": [
315 | "Используйте `tf.GradientTape` для обучения модели:"
316 | ]
317 | },
318 | {
319 | "cell_type": "code",
320 | "metadata": {
321 | "colab_type": "code",
322 | "id": "OZACiVqA8KQV",
323 | "colab": {}
324 | },
325 | "source": [
326 | "@tf.function\n",
327 | "def train_step(images, labels):\n",
328 | " with tf.GradientTape() as tape:\n",
329 | " predictions = model(images)\n",
330 | " loss = loss_object(labels, predictions)\n",
331 | " gradients = tape.gradient(loss, model.trainable_variables)\n",
332 | " optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
333 | "\n",
334 | " train_loss(loss)\n",
335 | " train_accuracy(labels, predictions)"
336 | ],
337 | "execution_count": 0,
338 | "outputs": []
339 | },
340 | {
341 | "cell_type": "markdown",
342 | "metadata": {
343 | "colab_type": "text",
344 | "id": "Z8YT7UmFgpjV"
345 | },
346 | "source": [
347 | "Протестируйте модель:"
348 | ]
349 | },
350 | {
351 | "cell_type": "code",
352 | "metadata": {
353 | "colab_type": "code",
354 | "id": "xIKdEzHAJGt7",
355 | "colab": {}
356 | },
357 | "source": [
358 | "@tf.function\n",
359 | "def test_step(images, labels):\n",
360 | " predictions = model(images)\n",
361 | " t_loss = loss_object(labels, predictions)\n",
362 | "\n",
363 | " test_loss(t_loss)\n",
364 | " test_accuracy(labels, predictions)"
365 | ],
366 | "execution_count": 0,
367 | "outputs": []
368 | },
369 | {
370 | "cell_type": "code",
371 | "metadata": {
372 | "colab_type": "code",
373 | "id": "i-2pkctU_Ci7",
374 | "colab": {}
375 | },
376 | "source": [
377 | "EPOCHS = 5\n",
378 | "\n",
379 | "for epoch in range(EPOCHS):\n",
380 | " for images, labels in train_ds:\n",
381 | " train_step(images, labels)\n",
382 | "\n",
383 | " for test_images, test_labels in test_ds:\n",
384 | " test_step(test_images, test_labels)\n",
385 | "\n",
386 | " template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'\n",
387 | " print (template.format(epoch+1,\n",
388 | " train_loss.result(),\n",
389 | " train_accuracy.result()*100,\n",
390 | " test_loss.result(),\n",
391 | " test_accuracy.result()*100))"
392 | ],
393 | "execution_count": 0,
394 | "outputs": []
395 | },
396 | {
397 | "cell_type": "markdown",
398 | "metadata": {
399 | "colab_type": "text",
400 | "id": "T4JfEh7kvx6m"
401 | },
402 | "source": [
403 | "Классификатор изображений теперь обучен на этих данных с точностью ~ 98%. Чтобы узнать больше, прочитайте [учебники по TensorFlow](https://www.tensorflow.org/tutorials/)."
404 | ]
405 | }
406 | ]
407 | }
408 |
--------------------------------------------------------------------------------
/docs-r2.1/ru/tutorials/quickstart/beginner.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "beginner.ipynb",
7 | "version": "0.3.2",
8 | "provenance": [],
9 | "private_outputs": true,
10 | "collapsed_sections": [],
11 | "toc_visible": true
12 | },
13 | "kernelspec": {
14 | "display_name": "Python 3",
15 | "name": "python3"
16 | }
17 | },
18 | "cells": [
19 | {
20 | "cell_type": "markdown",
21 | "metadata": {
22 | "colab_type": "text",
23 | "id": "rX8mhOLljYeM"
24 | },
25 | "source": [
26 | "##### Copyright 2019 The TensorFlow Authors."
27 | ]
28 | },
29 | {
30 | "cell_type": "code",
31 | "metadata": {
32 | "cellView": "form",
33 | "colab_type": "code",
34 | "id": "BZSlp3DAjdYf",
35 | "colab": {}
36 | },
37 | "source": [
38 | "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
39 | "# you may not use this file except in compliance with the License.\n",
40 | "# You may obtain a copy of the License at\n",
41 | "#\n",
42 | "# https://www.apache.org/licenses/LICENSE-2.0\n",
43 | "#\n",
44 | "# Unless required by applicable law or agreed to in writing, software\n",
45 | "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
46 | "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
47 | "# See the License for the specific language governing permissions and\n",
48 | "# limitations under the License."
49 | ],
50 | "execution_count": 0,
51 | "outputs": []
52 | },
53 | {
54 | "cell_type": "markdown",
55 | "metadata": {
56 | "colab_type": "text",
57 | "id": "3wF5wszaj97Y"
58 | },
59 | "source": [
60 | "# Начните с TensorFlow 2.0 для новичков"
61 | ]
62 | },
63 | {
64 | "cell_type": "markdown",
65 | "metadata": {
66 | "colab_type": "text",
67 | "id": "DUNzJc4jTj6G"
68 | },
69 | "source": [
70 | ""
84 | ]
85 | },
86 | {
87 | "cell_type": "markdown",
88 | "metadata": {
89 | "id": "10jPgwiVOBbc",
90 | "colab_type": "text"
91 | },
92 | "source": [
93 | "Note: Вся информация в этом разделе переведена с помощью русскоговорящего Tensorflow сообщества на общественных началах. Поскольку этот перевод не является официальным, мы не гарантируем что он на 100% аккуратен и соответствует [официальной документации на английском языке](https://www.tensorflow.org/?hl=en). Если у вас есть предложение как исправить этот перевод, мы будем очень рады увидеть pull request в [tensorflow/docs](https://github.com/tensorflow/docs) репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим), напишите нам на [docs-ru@tensorflow.org list](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ru)."
94 | ]
95 | },
96 | {
97 | "cell_type": "markdown",
98 | "metadata": {
99 | "colab_type": "text",
100 | "id": "hiH7AC-NTniF"
101 | },
102 | "source": [
103 | "Это файл [Google Colaboratory](https://colab.research.google.com/notebooks/welcome.ipynb) notebook. Программы Python programs запускающиеся прямо в браузере - хороший способ учить и использовать TensorFlow. Чтобы следовать этому руководству, запустите notebook в Google Colab нажав на соответствующую кнопку вверху этой страницы.\n",
104 | "\n",
105 | "1. В Colab подключитесь к среде исполнения Python: в правом верхнем углу строки меню выберите *CONNECT*.\n",
106 | "2. Запустите код во всех ячейках notebook: Выберите *Runtime* и *Run all*."
107 | ]
108 | },
109 | {
110 | "cell_type": "markdown",
111 | "metadata": {
112 | "colab_type": "text",
113 | "id": "nnrWf3PCEzXL"
114 | },
115 | "source": [
116 | "Скачайте и установите пакет TensorFlow 2.0 Beta. Импортируйте в вашу программу TensorFlow:"
117 | ]
118 | },
119 | {
120 | "cell_type": "code",
121 | "metadata": {
122 | "colab_type": "code",
123 | "id": "0trJmd6DjqBZ",
124 | "colab": {}
125 | },
126 | "source": [
127 | "from __future__ import absolute_import, division, print_function, unicode_literals\n",
128 | "\n",
129 | "# Install TensorFlow\n",
130 | "try:\n",
131 | " # Colab only\n",
132 | " %tensorflow_version 2.x\n",
133 | "except Exception:\n",
134 | " pass\n",
135 | "\n",
136 | "import tensorflow as tf"
137 | ],
138 | "execution_count": 0,
139 | "outputs": []
140 | },
141 | {
142 | "cell_type": "markdown",
143 | "metadata": {
144 | "colab_type": "text",
145 | "id": "7NAbSZiaoJ4z"
146 | },
147 | "source": [
148 | "Загрузите и установите [набор данных MNIST](http://yann.lecun.com/exdb/mnist/). Преобразуйте примеры из целых чисел в числа с плавающей запятой:"
149 | ]
150 | },
151 | {
152 | "cell_type": "code",
153 | "metadata": {
154 | "colab_type": "code",
155 | "id": "7FP5258xjs-v",
156 | "colab": {}
157 | },
158 | "source": [
159 | "mnist = tf.keras.datasets.mnist\n",
160 | "\n",
161 | "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
162 | "x_train, x_test = x_train / 255.0, x_test / 255.0"
163 | ],
164 | "execution_count": 0,
165 | "outputs": []
166 | },
167 | {
168 | "cell_type": "markdown",
169 | "metadata": {
170 | "colab_type": "text",
171 | "id": "BPZ68wASog_I"
172 | },
173 | "source": [
174 | "Создайте модель `tf.keras.Sequential`, сложив слои. Выберите оптимизатор и функцию потерь для обучения:"
175 | ]
176 | },
177 | {
178 | "cell_type": "code",
179 | "metadata": {
180 | "colab_type": "code",
181 | "id": "h3IKyzTCDNGo",
182 | "colab": {}
183 | },
184 | "source": [
185 | "model = tf.keras.models.Sequential([\n",
186 | " tf.keras.layers.Flatten(input_shape=(28, 28)),\n",
187 | " tf.keras.layers.Dense(128, activation='relu'),\n",
188 | " tf.keras.layers.Dropout(0.2),\n",
189 | " tf.keras.layers.Dense(10, activation='softmax')\n",
190 | "])\n",
191 | "\n",
192 | "model.compile(optimizer='adam',\n",
193 | " loss='sparse_categorical_crossentropy',\n",
194 | " metrics=['accuracy'])"
195 | ],
196 | "execution_count": 0,
197 | "outputs": []
198 | },
199 | {
200 | "cell_type": "markdown",
201 | "metadata": {
202 | "colab_type": "text",
203 | "id": "ix4mEL65on-w"
204 | },
205 | "source": [
206 | "Обучите и оцените модель:"
207 | ]
208 | },
209 | {
210 | "cell_type": "code",
211 | "metadata": {
212 | "colab_type": "code",
213 | "id": "F7dTAzgHDUh7",
214 | "colab": {}
215 | },
216 | "source": [
217 | "model.fit(x_train, y_train, epochs=5)\n",
218 | "\n",
219 | "model.evaluate(x_test, y_test, verbose=2)"
220 | ],
221 | "execution_count": 0,
222 | "outputs": []
223 | },
224 | {
225 | "cell_type": "markdown",
226 | "metadata": {
227 | "colab_type": "text",
228 | "id": "T4JfEh7kvx6m"
229 | },
230 | "source": [
231 | "Классификатор изображений теперь обучен на этих данных с точностью ~ 98%. Чтобы узнать больше, прочитайте [учебники по TensorFlow](https://www.tensorflow.org/tutorials/)."
232 | ]
233 | }
234 | ]
235 | }
236 |
--------------------------------------------------------------------------------
/site/en/tutorials/keras/basic-regression.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "basic-regression.ipynb",
7 | "version": "0.3.2",
8 | "provenance": [],
9 | "private_outputs": true,
10 | "collapsed_sections": [
11 | "FhGuhbZ6M5tl"
12 | ],
13 | "toc_visible": true
14 | },
15 | "kernelspec": {
16 | "name": "python3",
17 | "display_name": "Python 3"
18 | }
19 | },
20 | "cells": [
21 | {
22 | "metadata": {
23 | "id": "FhGuhbZ6M5tl",
24 | "colab_type": "text"
25 | },
26 | "cell_type": "markdown",
27 | "source": [
28 | "##### Copyright 2018 The TensorFlow Authors."
29 | ]
30 | },
31 | {
32 | "metadata": {
33 | "id": "AwOEIRJC6Une",
34 | "colab_type": "code",
35 | "colab": {}
36 | },
37 | "cell_type": "code",
38 | "source": [
39 | "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
40 | "# you may not use this file except in compliance with the License.\n",
41 | "# You may obtain a copy of the License at\n",
42 | "#\n",
43 | "# https://www.apache.org/licenses/LICENSE-2.0\n",
44 | "#\n",
45 | "# Unless required by applicable law or agreed to in writing, software\n",
46 | "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
47 | "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
48 | "# See the License for the specific language governing permissions and\n",
49 | "# limitations under the License."
50 | ],
51 | "execution_count": 0,
52 | "outputs": []
53 | },
54 | {
55 | "metadata": {
56 | "id": "KyPEtTqk6VdG",
57 | "colab_type": "code",
58 | "colab": {}
59 | },
60 | "cell_type": "code",
61 | "source": [
62 | "#@title MIT License\n",
63 | "#\n",
64 | "# Copyright (c) 2017 François Chollet\n",
65 | "#\n",
66 | "# Permission is hereby granted, free of charge, to any person obtaining a\n",
67 | "# copy of this software and associated documentation files (the \"Software\"),\n",
68 | "# to deal in the Software without restriction, including without limitation\n",
69 | "# the rights to use, copy, modify, merge, publish, distribute, sublicense,\n",
70 | "# and/or sell copies of the Software, and to permit persons to whom the\n",
71 | "# Software is furnished to do so, subject to the following conditions:\n",
72 | "#\n",
73 | "# The above copyright notice and this permission notice shall be included in\n",
74 | "# all copies or substantial portions of the Software.\n",
75 | "#\n",
76 | "# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
77 | "# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
78 | "# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n",
79 | "# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
80 | "# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n",
81 | "# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n",
82 | "# DEALINGS IN THE SOFTWARE."
83 | ],
84 | "execution_count": 0,
85 | "outputs": []
86 | },
87 | {
88 | "metadata": {
89 | "id": "EIdT9iu_Z4Rb",
90 | "colab_type": "text"
91 | },
92 | "cell_type": "markdown",
93 | "source": [
94 | "# Predict house prices: regression"
95 | ]
96 | },
97 | {
98 | "metadata": {
99 | "id": "bBIlTPscrIT9",
100 | "colab_type": "text"
101 | },
102 | "cell_type": "markdown",
103 | "source": [
104 | ""
115 | ]
116 | },
117 | {
118 | "metadata": {
119 | "id": "AHp3M9ZmrIxj",
120 | "colab_type": "text"
121 | },
122 | "cell_type": "markdown",
123 | "source": [
124 | "In a *regression* problem, we aim to predict the output of a continuous value, like a price or a probability. Contrast this with a *classification* problem, where we aim to predict a discrete label (for example, where a picture contains an apple or an orange). \n",
125 | "\n",
126 | "This notebook builds a model to predict the median price of homes in a Boston suburb during the mid-1970s. To do this, we'll provide the model with some data points about the suburb, such as the crime rate and the local property tax rate.\n",
127 | "\n",
128 | "This example uses the `tf.keras` API, see [this guide](https://www.tensorflow.org/guide/keras) for details."
129 | ]
130 | },
131 | {
132 | "metadata": {
133 | "id": "1rRo8oNqZ-Rj",
134 | "colab_type": "code",
135 | "colab": {}
136 | },
137 | "cell_type": "code",
138 | "source": [
139 | "from __future__ import absolute_import, division, print_function\n",
140 | "\n",
141 | "import tensorflow as tf\n",
142 | "from tensorflow import keras\n",
143 | "\n",
144 | "import numpy as np\n",
145 | "\n",
146 | "print(tf.__version__)"
147 | ],
148 | "execution_count": 0,
149 | "outputs": []
150 | },
151 | {
152 | "metadata": {
153 | "id": "F_72b0LCNbjx",
154 | "colab_type": "text"
155 | },
156 | "cell_type": "markdown",
157 | "source": [
158 | "## The Boston Housing Prices dataset\n",
159 | "\n",
160 | "This [dataset](https://www.cs.toronto.edu/~delve/data/boston/bostonDetail.html) is accessible directly in TensorFlow. Download and shuffle the training set:"
161 | ]
162 | },
163 | {
164 | "metadata": {
165 | "id": "p9kxxgzvzlyz",
166 | "colab_type": "code",
167 | "colab": {}
168 | },
169 | "cell_type": "code",
170 | "source": [
171 | "boston_housing = keras.datasets.boston_housing\n",
172 | "\n",
173 | "(train_data, train_labels), (test_data, test_labels) = boston_housing.load_data()\n",
174 | "\n",
175 | "# Shuffle the training set\n",
176 | "order = np.argsort(np.random.random(train_labels.shape))\n",
177 | "train_data = train_data[order]\n",
178 | "train_labels = train_labels[order]"
179 | ],
180 | "execution_count": 0,
181 | "outputs": []
182 | },
183 | {
184 | "metadata": {
185 | "id": "PwEKwRJgsgJ6",
186 | "colab_type": "text"
187 | },
188 | "cell_type": "markdown",
189 | "source": [
190 | "### Examples and features\n",
191 | "\n",
192 | "This dataset is much smaller than the others we've worked with so far: it has 506 total examples are split between 404 training examples and 102 test examples:"
193 | ]
194 | },
195 | {
196 | "metadata": {
197 | "id": "Ujqcgkipr65P",
198 | "colab_type": "code",
199 | "colab": {}
200 | },
201 | "cell_type": "code",
202 | "source": [
203 | "print(\"Training set: {}\".format(train_data.shape)) # 404 examples, 13 features\n",
204 | "print(\"Testing set: {}\".format(test_data.shape)) # 102 examples, 13 features"
205 | ],
206 | "execution_count": 0,
207 | "outputs": []
208 | },
209 | {
210 | "metadata": {
211 | "id": "0LRPXE3Oz3Nq",
212 | "colab_type": "text"
213 | },
214 | "cell_type": "markdown",
215 | "source": [
216 | "The dataset contains 13 different features:\n",
217 | "\n",
218 | "1. Per capita crime rate.\n",
219 | "2. The proportion of residential land zoned for lots over 25,000 square feet.\n",
220 | "3. The proportion of non-retail business acres per town.\n",
221 | "4. Charles River dummy variable (= 1 if tract bounds river; 0 otherwise).\n",
222 | "5. Nitric oxides concentration (parts per 10 million).\n",
223 | "6. The average number of rooms per dwelling.\n",
224 | "7. The proportion of owner-occupied units built before 1940.\n",
225 | "8. Weighted distances to five Boston employment centers.\n",
226 | "9. Index of accessibility to radial highways.\n",
227 | "10. Full-value property-tax rate per $10,000.\n",
228 | "11. Pupil-teacher ratio by town.\n",
229 | "12. 1000 * (Bk - 0.63) ** 2 where Bk is the proportion of Black people by town.\n",
230 | "13. Percentage lower status of the population.\n",
231 | "\n",
232 | "Each one of these input data features is stored using a different scale. Some features are represented by a proportion between 0 and 1, other features are ranges between 1 and 12, some are ranges between 0 and 100, and so on. This is often the case with real-world data, and understanding how to explore and clean such data is an important skill to develop.\n",
233 | "\n",
234 | "Key Point: As a modeler and developer, think about how this data is used and the potential benefits and harm a model's predictions can cause. A model like this could reinforce societal biases and disparities. Is a feature relevant to the problem you want to solve or will it introduce bias? For more information, read about [ML fairness](https://developers.google.com/machine-learning/fairness-overview/)."
235 | ]
236 | },
237 | {
238 | "metadata": {
239 | "id": "8tYsm8Gs03J4",
240 | "colab_type": "code",
241 | "colab": {}
242 | },
243 | "cell_type": "code",
244 | "source": [
245 | "print(train_data[0]) # Display sample features, notice the different scales"
246 | ],
247 | "execution_count": 0,
248 | "outputs": []
249 | },
250 | {
251 | "metadata": {
252 | "id": "Q7muNf-d1-ne",
253 | "colab_type": "text"
254 | },
255 | "cell_type": "markdown",
256 | "source": [
257 | "Use the [pandas](https://pandas.pydata.org) library to display the first few rows of the dataset in a nicely formatted table:"
258 | ]
259 | },
260 | {
261 | "metadata": {
262 | "id": "pYVyGhdyCpIM",
263 | "colab_type": "code",
264 | "colab": {}
265 | },
266 | "cell_type": "code",
267 | "source": [
268 | "import pandas as pd\n",
269 | "\n",
270 | "column_names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',\n",
271 | " 'TAX', 'PTRATIO', 'B', 'LSTAT']\n",
272 | "\n",
273 | "df = pd.DataFrame(train_data, columns=column_names)\n",
274 | "df.head()"
275 | ],
276 | "execution_count": 0,
277 | "outputs": []
278 | },
279 | {
280 | "metadata": {
281 | "id": "wb9S7Mia2lpf",
282 | "colab_type": "text"
283 | },
284 | "cell_type": "markdown",
285 | "source": [
286 | "### Labels\n",
287 | "\n",
288 | "The labels are the house prices in thousands of dollars. (You may notice the mid-1970s prices.)"
289 | ]
290 | },
291 | {
292 | "metadata": {
293 | "id": "I8NwI2ND2t4Y",
294 | "colab_type": "code",
295 | "colab": {}
296 | },
297 | "cell_type": "code",
298 | "source": [
299 | "print(train_labels[0:10]) # Display first 10 entries"
300 | ],
301 | "execution_count": 0,
302 | "outputs": []
303 | },
304 | {
305 | "metadata": {
306 | "id": "mRklxK5s388r",
307 | "colab_type": "text"
308 | },
309 | "cell_type": "markdown",
310 | "source": [
311 | "## Normalize features\n",
312 | "\n",
313 | "It's recommended to normalize features that use different scales and ranges. For each feature, subtract the mean of the feature and divide by the standard deviation:"
314 | ]
315 | },
316 | {
317 | "metadata": {
318 | "id": "ze5WQP8R1TYg",
319 | "colab_type": "code",
320 | "colab": {}
321 | },
322 | "cell_type": "code",
323 | "source": [
324 | "# Test data is *not* used when calculating the mean and std\n",
325 | "\n",
326 | "mean = train_data.mean(axis=0)\n",
327 | "std = train_data.std(axis=0)\n",
328 | "train_data = (train_data - mean) / std\n",
329 | "test_data = (test_data - mean) / std\n",
330 | "\n",
331 | "print(train_data[0]) # First training sample, normalized"
332 | ],
333 | "execution_count": 0,
334 | "outputs": []
335 | },
336 | {
337 | "metadata": {
338 | "id": "BuiClDk45eS4",
339 | "colab_type": "text"
340 | },
341 | "cell_type": "markdown",
342 | "source": [
343 | "Although the model *might* converge without feature normalization, it makes training more difficult, and it makes the resulting model more dependent on the choice of units used in the input."
344 | ]
345 | },
346 | {
347 | "metadata": {
348 | "id": "SmjdzxKzEu1-",
349 | "colab_type": "text"
350 | },
351 | "cell_type": "markdown",
352 | "source": [
353 | "## Create the model\n",
354 | "\n",
355 | "Let's build our model. Here, we'll use a `Sequential` model with two densely connected hidden layers, and an output layer that returns a single, continuous value. The model building steps are wrapped in a function, `build_model`, since we'll create a second model, later on."
356 | ]
357 | },
358 | {
359 | "metadata": {
360 | "id": "c26juK7ZG8j-",
361 | "colab_type": "code",
362 | "colab": {}
363 | },
364 | "cell_type": "code",
365 | "source": [
366 | "def build_model():\n",
367 | " model = keras.Sequential([\n",
368 | " keras.layers.Dense(64, activation=tf.nn.relu,\n",
369 | " input_shape=(train_data.shape[1],)),\n",
370 | " keras.layers.Dense(64, activation=tf.nn.relu),\n",
371 | " keras.layers.Dense(1)\n",
372 | " ])\n",
373 | "\n",
374 | " optimizer = tf.train.RMSPropOptimizer(0.001)\n",
375 | "\n",
376 | " model.compile(loss='mse',\n",
377 | " optimizer=optimizer,\n",
378 | " metrics=['mae'])\n",
379 | " return model\n",
380 | "\n",
381 | "model = build_model()\n",
382 | "model.summary()"
383 | ],
384 | "execution_count": 0,
385 | "outputs": []
386 | },
387 | {
388 | "metadata": {
389 | "id": "0-qWCsh6DlyH",
390 | "colab_type": "text"
391 | },
392 | "cell_type": "markdown",
393 | "source": [
394 | "## Train the model\n",
395 | "\n",
396 | "The model is trained for 500 epochs, and record the training and validation accuracy in the `history` object."
397 | ]
398 | },
399 | {
400 | "metadata": {
401 | "id": "sD7qHCmNIOY0",
402 | "colab_type": "code",
403 | "colab": {}
404 | },
405 | "cell_type": "code",
406 | "source": [
407 | "# Display training progress by printing a single dot for each completed epoch\n",
408 | "class PrintDot(keras.callbacks.Callback):\n",
409 | " def on_epoch_end(self, epoch, logs):\n",
410 | " if epoch % 100 == 0: print('')\n",
411 | " print('.', end='')\n",
412 | "\n",
413 | "EPOCHS = 500\n",
414 | "\n",
415 | "# Store training stats\n",
416 | "history = model.fit(train_data, train_labels, epochs=EPOCHS,\n",
417 | " validation_split=0.2, verbose=0,\n",
418 | " callbacks=[PrintDot()])"
419 | ],
420 | "execution_count": 0,
421 | "outputs": []
422 | },
423 | {
424 | "metadata": {
425 | "id": "tQm3pc0FYPQB",
426 | "colab_type": "text"
427 | },
428 | "cell_type": "markdown",
429 | "source": [
430 | "Visualize the model's training progress using the stats stored in the `history` object. We want to use this data to determine how long to train *before* the model stops making progress."
431 | ]
432 | },
433 | {
434 | "metadata": {
435 | "id": "B6XriGbVPh2t",
436 | "colab_type": "code",
437 | "colab": {}
438 | },
439 | "cell_type": "code",
440 | "source": [
441 | "import matplotlib.pyplot as plt\n",
442 | "\n",
443 | "\n",
444 | "def plot_history(history):\n",
445 | " plt.figure()\n",
446 | " plt.xlabel('Epoch')\n",
447 | " plt.ylabel('Mean Abs Error [1000$]')\n",
448 | " plt.plot(history.epoch, np.array(history.history['mean_absolute_error']),\n",
449 | " label='Train Loss')\n",
450 | " plt.plot(history.epoch, np.array(history.history['val_mean_absolute_error']),\n",
451 | " label = 'Val loss')\n",
452 | " plt.legend()\n",
453 | " plt.ylim([0, 5])\n",
454 | "\n",
455 | "plot_history(history)"
456 | ],
457 | "execution_count": 0,
458 | "outputs": []
459 | },
460 | {
461 | "metadata": {
462 | "id": "AqsuANc11FYv",
463 | "colab_type": "text"
464 | },
465 | "cell_type": "markdown",
466 | "source": [
467 | "This graph shows little improvement in the model after about 200 epochs. Let's update the `model.fit` method to automatically stop training when the validation score doesn't improve. We'll use a *callback* that tests a training condition for every epoch. If a set amount of epochs elapses without showing improvement, then automatically stop the training.\n",
468 | "\n",
469 | "You can learn more about this callback [here](https://www.tensorflow.org/versions/master/api_docs/python/tf/keras/callbacks/EarlyStopping)."
470 | ]
471 | },
472 | {
473 | "metadata": {
474 | "id": "fdMZuhUgzMZ4",
475 | "colab_type": "code",
476 | "colab": {}
477 | },
478 | "cell_type": "code",
479 | "source": [
480 | "model = build_model()\n",
481 | "\n",
482 | "# The patience parameter is the amount of epochs to check for improvement\n",
483 | "early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=20)\n",
484 | "\n",
485 | "history = model.fit(train_data, train_labels, epochs=EPOCHS,\n",
486 | " validation_split=0.2, verbose=0,\n",
487 | " callbacks=[early_stop, PrintDot()])\n",
488 | "\n",
489 | "plot_history(history)"
490 | ],
491 | "execution_count": 0,
492 | "outputs": []
493 | },
494 | {
495 | "metadata": {
496 | "id": "3St8-DmrX8P4",
497 | "colab_type": "text"
498 | },
499 | "cell_type": "markdown",
500 | "source": [
501 | "The graph shows the average error is about \\\\$2,500 dollars. Is this good? Well, \\$2,500 is not an insignificant amount when some of the labels are only $15,000.\n",
502 | "\n",
503 | "Let's see how did the model performs on the test set:"
504 | ]
505 | },
506 | {
507 | "metadata": {
508 | "id": "jl_yNr5n1kms",
509 | "colab_type": "code",
510 | "colab": {}
511 | },
512 | "cell_type": "code",
513 | "source": [
514 | "[loss, mae] = model.evaluate(test_data, test_labels, verbose=0)\n",
515 | "\n",
516 | "print(\"Testing set Mean Abs Error: ${:7.2f}\".format(mae * 1000))"
517 | ],
518 | "execution_count": 0,
519 | "outputs": []
520 | },
521 | {
522 | "metadata": {
523 | "id": "ft603OzXuEZC",
524 | "colab_type": "text"
525 | },
526 | "cell_type": "markdown",
527 | "source": [
528 | "## Predict\n",
529 | "\n",
530 | "Finally, predict some housing prices using data in the testing set:"
531 | ]
532 | },
533 | {
534 | "metadata": {
535 | "id": "Xe7RXH3N3CWU",
536 | "colab_type": "code",
537 | "colab": {}
538 | },
539 | "cell_type": "code",
540 | "source": [
541 | "test_predictions = model.predict(test_data).flatten()\n",
542 | "\n",
543 | "plt.scatter(test_labels, test_predictions)\n",
544 | "plt.xlabel('True Values [1000$]')\n",
545 | "plt.ylabel('Predictions [1000$]')\n",
546 | "plt.axis('equal')\n",
547 | "plt.xlim(plt.xlim())\n",
548 | "plt.ylim(plt.ylim())\n",
549 | "_ = plt.plot([-100, 100], [-100, 100])\n"
550 | ],
551 | "execution_count": 0,
552 | "outputs": []
553 | },
554 | {
555 | "metadata": {
556 | "id": "f-OHX4DiXd8x",
557 | "colab_type": "code",
558 | "colab": {}
559 | },
560 | "cell_type": "code",
561 | "source": [
562 | "error = test_predictions - test_labels\n",
563 | "plt.hist(error, bins = 50)\n",
564 | "plt.xlabel(\"Prediction Error [1000$]\")\n",
565 | "_ = plt.ylabel(\"Count\")"
566 | ],
567 | "execution_count": 0,
568 | "outputs": []
569 | },
570 | {
571 | "metadata": {
572 | "id": "vgGQuV-yqYZH",
573 | "colab_type": "text"
574 | },
575 | "cell_type": "markdown",
576 | "source": [
577 | "## Conclusion\n",
578 | "\n",
579 | "This notebook introduced a few techniques to handle a regression problem.\n",
580 | "\n",
581 | "* Mean Squared Error (MSE) is a common loss function used for regression problems (different than classification problems).\n",
582 | "* Similarly, evaluation metrics used for regression differ from classification. A common regression metric is Mean Absolute Error (MAE).\n",
583 | "* When input data features have values with different ranges, each feature should be scaled independently.\n",
584 | "* If there is not much training data, prefer a small network with few hidden layers to avoid overfitting.\n",
585 | "* Early stopping is a useful technique to prevent overfitting."
586 | ]
587 | }
588 | ]
589 | }
590 |
--------------------------------------------------------------------------------
/site/ru/tutorials/keras/basic_regression.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "colab_type": "text",
7 | "id": "FhGuhbZ6M5tl"
8 | },
9 | "source": [
10 | "##### Copyright 2018 The TensorFlow Authors."
11 | ]
12 | },
13 | {
14 | "cell_type": "code",
15 | "execution_count": null,
16 | "metadata": {
17 | "colab": {},
18 | "colab_type": "code",
19 | "id": "AwOEIRJC6Une"
20 | },
21 | "outputs": [],
22 | "source": [
23 | "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
24 | "# you may not use this file except in compliance with the License.\n",
25 | "# You may obtain a copy of the License at\n",
26 | "#\n",
27 | "# https://www.apache.org/licenses/LICENSE-2.0\n",
28 | "#\n",
29 | "# Unless required by applicable law or agreed to in writing, software\n",
30 | "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
31 | "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
32 | "# See the License for the specific language governing permissions and\n",
33 | "# limitations under the License."
34 | ]
35 | },
36 | {
37 | "cell_type": "code",
38 | "execution_count": null,
39 | "metadata": {
40 | "colab": {},
41 | "colab_type": "code",
42 | "id": "KyPEtTqk6VdG"
43 | },
44 | "outputs": [],
45 | "source": [
46 | "#@title MIT License\n",
47 | "#\n",
48 | "# Copyright (c) 2017 François Chollet\n",
49 | "#\n",
50 | "# Permission is hereby granted, free of charge, to any person obtaining a\n",
51 | "# copy of this software and associated documentation files (the \"Software\"),\n",
52 | "# to deal in the Software without restriction, including without limitation\n",
53 | "# the rights to use, copy, modify, merge, publish, distribute, sublicense,\n",
54 | "# and/or sell copies of the Software, and to permit persons to whom the\n",
55 | "# Software is furnished to do so, subject to the following conditions:\n",
56 | "#\n",
57 | "# The above copyright notice and this permission notice shall be included in\n",
58 | "# all copies or substantial portions of the Software.\n",
59 | "#\n",
60 | "# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
61 | "# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
62 | "# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n",
63 | "# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
64 | "# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n",
65 | "# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n",
66 | "# DEALINGS IN THE SOFTWARE."
67 | ]
68 | },
69 | {
70 | "cell_type": "markdown",
71 | "metadata": {
72 | "colab_type": "text",
73 | "id": "EIdT9iu_Z4Rb"
74 | },
75 | "source": [
76 | "# Предсказывай цены на недвижимость: регрессия"
77 | ]
78 | },
79 | {
80 | "cell_type": "markdown",
81 | "metadata": {
82 | "colab_type": "text",
83 | "id": "bBIlTPscrIT9"
84 | },
85 | "source": [
86 | ""
97 | ]
98 | },
99 | {
100 | "cell_type": "markdown",
101 | "metadata": {
102 | "colab_type": "text",
103 | "id": "AHp3M9ZmrIxj"
104 | },
105 | "source": [
106 | "Говоря о задачах *регрессии*, мы преследуем цель дать прогноз какого-либо значения, например цену или вероятность. Это уже совсем другая задача если сравненить с *классификацией*, где нужно предсказать конкретный класс или категорию (например, яблоко или апельсин на картинке).\n",
107 | "\n",
108 | "В этом уроке мы построим модель, которая предсказывает медианную стоимость жилого дома в пригороде Бостона середины 1970-х. Чтобы это сделать, нам потребуются также некоторые данные об этом пригороде, например уровень преступности и налог на недвижимость.\n",
109 | "\n",
110 | "В этом примере используется `tf.keras` API, подробнее [смотри здесь](https://www.tensorflow.org/guide/keras)."
111 | ]
112 | },
113 | {
114 | "cell_type": "code",
115 | "execution_count": null,
116 | "metadata": {
117 | "colab": {},
118 | "colab_type": "code",
119 | "id": "1rRo8oNqZ-Rj"
120 | },
121 | "outputs": [],
122 | "source": [
123 | "from __future__ import absolute_import, division, print_function\n",
124 | "\n",
125 | "import tensorflow as tf\n",
126 | "from tensorflow import keras\n",
127 | "\n",
128 | "import numpy as np\n",
129 | "\n",
130 | "print(tf.__version__)"
131 | ]
132 | },
133 | {
134 | "cell_type": "markdown",
135 | "metadata": {
136 | "colab_type": "text",
137 | "id": "F_72b0LCNbjx"
138 | },
139 | "source": [
140 | "## Загружаем данные с ценами на жилье Бостоне\n",
141 | "\n",
142 | "Этот [датасет](https://www.cs.toronto.edu/~delve/data/boston/bostonDetail.html) доступен сразу в TensorFlow. Скачаем его и перемешаем данные:"
143 | ]
144 | },
145 | {
146 | "cell_type": "code",
147 | "execution_count": null,
148 | "metadata": {
149 | "colab": {},
150 | "colab_type": "code",
151 | "id": "p9kxxgzvzlyz"
152 | },
153 | "outputs": [],
154 | "source": [
155 | "boston_housing = keras.datasets.boston_housing\n",
156 | "\n",
157 | "(train_data, train_labels), (test_data, test_labels) = boston_housing.load_data()\n",
158 | "\n",
159 | "# Перемешиваем данные в тренировочном сете\n",
160 | "order = np.argsort(np.random.random(train_labels.shape))\n",
161 | "train_data = train_data[order]\n",
162 | "train_labels = train_labels[order]"
163 | ]
164 | },
165 | {
166 | "cell_type": "markdown",
167 | "metadata": {
168 | "colab_type": "text",
169 | "id": "PwEKwRJgsgJ6"
170 | },
171 | "source": [
172 | "### Примеры и параметры данных\n",
173 | "\n",
174 | "Этот датасет намного меньше других, с которыми работали ранее: в нем всего 506 записей, из которых 404 предназачены для обучения, а 102 - для проверки:"
175 | ]
176 | },
177 | {
178 | "cell_type": "code",
179 | "execution_count": null,
180 | "metadata": {
181 | "colab": {},
182 | "colab_type": "code",
183 | "id": "Ujqcgkipr65P"
184 | },
185 | "outputs": [],
186 | "source": [
187 | "print(\"Training set: {}\".format(train_data.shape)) # 404 записи, 13 параметра\n",
188 | "print(\"Testing set: {}\".format(test_data.shape)) # 102 записи, 13 параметра"
189 | ]
190 | },
191 | {
192 | "cell_type": "markdown",
193 | "metadata": {
194 | "colab_type": "text",
195 | "id": "0LRPXE3Oz3Nq"
196 | },
197 | "source": [
198 | "Датасет содержит 13 разных параметров:\n",
199 | "\n",
200 | "1. Уровень преступности на душу населения\n",
201 | "2. Доля жилищных земель, районы свыше 25,000 кв. футов\n",
202 | "3. Доля нерозничных предприятий на район\n",
203 | "4. Переменная Charles River (равна 1 если земля имеет выход к воде; 0 - в противном случае)\n",
204 | "5. Концентрация выбросов азота\n",
205 | "6. Среднее количество комнат в доме\n",
206 | "7. Доля жилых домов, построенных до 1940 года\n",
207 | "8. Дистанция до пяти центров занятости Бостона\n",
208 | "9. Индекс доступности к дорожным автомагистралям\n",
209 | "10. Налоговая ставка на жилую недвижимость на $10,000\n",
210 | "11. Соотношение количества учеников и учителей на район\n",
211 | "12. 1000 * (Bk - 0.63) ** 2, где Bk - доля афроамериканцев на район\n",
212 | "13. Процент бедности населения\n",
213 | "\n",
214 | "Каждый из указанных параметров сохранен в разном формате. Некоторые параметры представлены пропорцией между 0 и 1, другие измеряются в диапазоне от 1 до 12, какие-то от 0 до 100, и так далее. Это наиболее частый случай когда мы имеем дело с реальными данными, и понимание того как анализировать и подготавливать такие данные является очень важным навыком.\n",
215 | "\n",
216 | "Важный момент:\n",
217 | "\n",
218 | "Как разработчик модели, подумай как эти данные могут быть использованы, а также какие потенциальные преимущества и возможный вред могут появиться в результате использования предсказаний модели. Модель наподобие этой может усилить общественные предубеждения и социальное неравенство. Является ли параметр, относящийся к решаемой проблеме, источником предубеждений? \n",
219 | "\n",
220 | "Прочитай про [справедливость в машинном обучении](https://developers.google.com/machine-learning/fairness-overview/)."
221 | ]
222 | },
223 | {
224 | "cell_type": "code",
225 | "execution_count": null,
226 | "metadata": {
227 | "colab": {},
228 | "colab_type": "code",
229 | "id": "8tYsm8Gs03J4"
230 | },
231 | "outputs": [],
232 | "source": [
233 | "print(train_data[0]) # Отображает примеры параметров, обрати внимание на разный формат данных"
234 | ]
235 | },
236 | {
237 | "cell_type": "markdown",
238 | "metadata": {
239 | "colab_type": "text",
240 | "id": "Q7muNf-d1-ne"
241 | },
242 | "source": [
243 | "Давай воспользуемся библиотекой [pandas](https://pandas.pydata.org) для отображения первых нескольких рядов датасета в виде понятной таблицы:"
244 | ]
245 | },
246 | {
247 | "cell_type": "code",
248 | "execution_count": null,
249 | "metadata": {
250 | "colab": {},
251 | "colab_type": "code",
252 | "id": "pYVyGhdyCpIM"
253 | },
254 | "outputs": [],
255 | "source": [
256 | "import pandas as pd\n",
257 | "\n",
258 | "column_names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',\n",
259 | " 'TAX', 'PTRATIO', 'B', 'LSTAT']\n",
260 | "\n",
261 | "df = pd.DataFrame(train_data, columns=column_names)\n",
262 | "df.head()"
263 | ]
264 | },
265 | {
266 | "cell_type": "markdown",
267 | "metadata": {
268 | "colab_type": "text",
269 | "id": "wb9S7Mia2lpf"
270 | },
271 | "source": [
272 | "### Цены\n",
273 | "\n",
274 | "Стоимость домов в нашем датасете указана как *label* в тысячах долларов (обрати внимание, что цены середины 70-х):"
275 | ]
276 | },
277 | {
278 | "cell_type": "code",
279 | "execution_count": null,
280 | "metadata": {
281 | "colab": {},
282 | "colab_type": "code",
283 | "id": "I8NwI2ND2t4Y"
284 | },
285 | "outputs": [],
286 | "source": [
287 | "print(train_labels[0:10]) # Выводит на экран первые 10 записей"
288 | ]
289 | },
290 | {
291 | "cell_type": "markdown",
292 | "metadata": {
293 | "colab_type": "text",
294 | "id": "mRklxK5s388r"
295 | },
296 | "source": [
297 | "## Нормализуем параметры\n",
298 | "\n",
299 | "Рекомендуется нормализовывать параметры которые используют различные форматы и диапазоны значений. Для каждого параметра вычтем среднее значение и разделим на среднеквадратическое отклонение:"
300 | ]
301 | },
302 | {
303 | "cell_type": "code",
304 | "execution_count": null,
305 | "metadata": {
306 | "colab": {},
307 | "colab_type": "code",
308 | "id": "ze5WQP8R1TYg"
309 | },
310 | "outputs": [],
311 | "source": [
312 | "# Проверочные данные *не используются* когда рассчитывается среднее значение и квадратическое отклонение\n",
313 | "\n",
314 | "mean = train_data.mean(axis=0)\n",
315 | "std = train_data.std(axis=0)\n",
316 | "train_data = (train_data - mean) / std\n",
317 | "test_data = (test_data - mean) / std\n",
318 | "\n",
319 | "print(train_data[0]) # Отобразим первую запись нормализованных данных"
320 | ]
321 | },
322 | {
323 | "cell_type": "markdown",
324 | "metadata": {
325 | "colab_type": "text",
326 | "id": "BuiClDk45eS4"
327 | },
328 | "source": [
329 | "Несмотря на то, что модель *может* стремиться к пределу без нормализации параметров, это делает обучение более сложным и получившаяся модель может быть более зависима от выбранных единиц измерения."
330 | ]
331 | },
332 | {
333 | "cell_type": "markdown",
334 | "metadata": {
335 | "colab_type": "text",
336 | "id": "SmjdzxKzEu1-"
337 | },
338 | "source": [
339 | "## Создаем модель\n",
340 | "\n",
341 | "Давай построим нашу модель. Мы будем использовать `Sequential` (пер. \"Последовательную\") модель, состоящую из двух полносвязных скрытых слоев, а также последнего слоя, который будет возвращать одно значение. Все шаги построения модели мы оформим в функцию `build_model`, потому что позже мы создадим еще одну модель."
342 | ]
343 | },
344 | {
345 | "cell_type": "code",
346 | "execution_count": null,
347 | "metadata": {
348 | "colab": {},
349 | "colab_type": "code",
350 | "id": "c26juK7ZG8j-"
351 | },
352 | "outputs": [],
353 | "source": [
354 | "def build_model():\n",
355 | " model = keras.Sequential([\n",
356 | " keras.layers.Dense(64, activation=tf.nn.relu,\n",
357 | " input_shape=(train_data.shape[1],)),\n",
358 | " keras.layers.Dense(64, activation=tf.nn.relu),\n",
359 | " keras.layers.Dense(1)\n",
360 | " ])\n",
361 | "\n",
362 | " optimizer = tf.train.RMSPropOptimizer(0.001)\n",
363 | "\n",
364 | " model.compile(loss='mse',\n",
365 | " optimizer=optimizer,\n",
366 | " metrics=['mae'])\n",
367 | " return model\n",
368 | "\n",
369 | "model = build_model()\n",
370 | "model.summary()"
371 | ]
372 | },
373 | {
374 | "cell_type": "markdown",
375 | "metadata": {
376 | "colab_type": "text",
377 | "id": "0-qWCsh6DlyH"
378 | },
379 | "source": [
380 | "## Обучаем модель\n",
381 | "\n",
382 | "Мы будем обучать модель в течение 500 эпох и записывать точность тренировки и проверки в объект `history`."
383 | ]
384 | },
385 | {
386 | "cell_type": "code",
387 | "execution_count": null,
388 | "metadata": {
389 | "colab": {},
390 | "colab_type": "code",
391 | "id": "sD7qHCmNIOY0"
392 | },
393 | "outputs": [],
394 | "source": [
395 | "# Покажем готовность процесса обучения: после каждой завершенной эпохи будет появляться точка\n",
396 | "class PrintDot(keras.callbacks.Callback):\n",
397 | " def on_epoch_end(self, epoch, logs):\n",
398 | " if epoch % 100 == 0: print('')\n",
399 | " print('.', end='')\n",
400 | "\n",
401 | "EPOCHS = 500\n",
402 | "\n",
403 | "# Сохраняем статистику обучения\n",
404 | "history = model.fit(train_data, train_labels, epochs=EPOCHS,\n",
405 | " validation_split=0.2, verbose=0,\n",
406 | " callbacks=[PrintDot()])"
407 | ]
408 | },
409 | {
410 | "cell_type": "markdown",
411 | "metadata": {
412 | "colab_type": "text",
413 | "id": "tQm3pc0FYPQB"
414 | },
415 | "source": [
416 | "Теперь построим график, чтобы визуализировать прогресс обучения модели при помощи сохраненной статистики из `history`. Это поможет нам определить как долго нужно обучать модель до того, как модель *перестанет улучшать* показатели точности."
417 | ]
418 | },
419 | {
420 | "cell_type": "code",
421 | "execution_count": null,
422 | "metadata": {
423 | "colab": {},
424 | "colab_type": "code",
425 | "id": "B6XriGbVPh2t"
426 | },
427 | "outputs": [],
428 | "source": [
429 | "import matplotlib.pyplot as plt\n",
430 | "\n",
431 | "def plot_history(history):\n",
432 | " plt.figure()\n",
433 | " plt.xlabel('Epoch')\n",
434 | " plt.ylabel('Mean Abs Error [1000$]')\n",
435 | " plt.plot(history.epoch, np.array(history.history['mean_absolute_error']),\n",
436 | " label='Train Loss')\n",
437 | " plt.plot(history.epoch, np.array(history.history['val_mean_absolute_error']),\n",
438 | " label = 'Val loss')\n",
439 | " plt.legend()\n",
440 | " plt.ylim([0, 5])\n",
441 | "\n",
442 | "plot_history(history)"
443 | ]
444 | },
445 | {
446 | "cell_type": "markdown",
447 | "metadata": {
448 | "colab_type": "text",
449 | "id": "AqsuANc11FYv"
450 | },
451 | "source": [
452 | "Эта схема показывает, что после 200 эпох наша модель улучшается совсем незначительно в процессе обучения. Давай обновим метод `model.fit` чтобы автоматически прекращать обучение как только показатель проверки *Val loss* не улучшается. Для этого мы используем функцию обратного вызова *callback*, которая проверяет показатели обучения после каждой эпохи. Если после определенного количество эпох нет никаких улучшений, то функиция остановит его.\n",
453 | "\n",
454 | "Читай больше про функцию *callback* [здесь](https://www.tensorflow.org/versions/master/api_docs/python/tf/keras/callbacks/EarlyStopping)."
455 | ]
456 | },
457 | {
458 | "cell_type": "code",
459 | "execution_count": null,
460 | "metadata": {
461 | "colab": {},
462 | "colab_type": "code",
463 | "id": "fdMZuhUgzMZ4"
464 | },
465 | "outputs": [],
466 | "source": [
467 | "model = build_model()\n",
468 | "\n",
469 | "# Параметр patience определяет количество эпох, которые можно пропустить без улучшений\n",
470 | "early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=20)\n",
471 | "\n",
472 | "history = model.fit(train_data, train_labels, epochs=EPOCHS,\n",
473 | " validation_split=0.2, verbose=0,\n",
474 | " callbacks=[early_stop, PrintDot()])\n",
475 | "\n",
476 | "plot_history(history)"
477 | ]
478 | },
479 | {
480 | "cell_type": "markdown",
481 | "metadata": {
482 | "colab_type": "text",
483 | "id": "3St8-DmrX8P4"
484 | },
485 | "source": [
486 | "График показывает, что средняя стоимость ошибки \\\\$2,500 долларов. Это хорошо или плохо? Ну, \\$2,500 не такая уж и большая сумма, если учитывать, что другие ярлыки имеют цены около $15,000.\n",
487 | "\n",
488 | "Давай посмотрим, как справится наша новая модель на данных для проверки:"
489 | ]
490 | },
491 | {
492 | "cell_type": "code",
493 | "execution_count": null,
494 | "metadata": {
495 | "colab": {},
496 | "colab_type": "code",
497 | "id": "jl_yNr5n1kms"
498 | },
499 | "outputs": [],
500 | "source": [
501 | "[loss, mae] = model.evaluate(test_data, test_labels, verbose=0)\n",
502 | "\n",
503 | "print(\"Testing set Mean Abs Error: ${:7.2f}\".format(mae * 1000))"
504 | ]
505 | },
506 | {
507 | "cell_type": "markdown",
508 | "metadata": {
509 | "colab_type": "text",
510 | "id": "ft603OzXuEZC"
511 | },
512 | "source": [
513 | "## Делаем предсказания\n",
514 | "\n",
515 | "Наконец давай предскажем цены на жилье, используя данные из проверочного сета:"
516 | ]
517 | },
518 | {
519 | "cell_type": "code",
520 | "execution_count": null,
521 | "metadata": {
522 | "colab": {},
523 | "colab_type": "code",
524 | "id": "Xe7RXH3N3CWU"
525 | },
526 | "outputs": [],
527 | "source": [
528 | "test_predictions = model.predict(test_data).flatten()\n",
529 | "\n",
530 | "plt.scatter(test_labels, test_predictions)\n",
531 | "plt.xlabel('True Values [1000$]')\n",
532 | "plt.ylabel('Predictions [1000$]')\n",
533 | "plt.axis('equal')\n",
534 | "plt.xlim(plt.xlim())\n",
535 | "plt.ylim(plt.ylim())\n",
536 | "_ = plt.plot([-100, 100], [-100, 100])\n"
537 | ]
538 | },
539 | {
540 | "cell_type": "code",
541 | "execution_count": null,
542 | "metadata": {
543 | "colab": {},
544 | "colab_type": "code",
545 | "id": "f-OHX4DiXd8x"
546 | },
547 | "outputs": [],
548 | "source": [
549 | "error = test_predictions - test_labels\n",
550 | "plt.hist(error, bins = 50)\n",
551 | "plt.xlabel(\"Prediction Error [1000$]\")\n",
552 | "_ = plt.ylabel(\"Count\")"
553 | ]
554 | },
555 | {
556 | "cell_type": "markdown",
557 | "metadata": {
558 | "colab_type": "text",
559 | "id": "vgGQuV-yqYZH"
560 | },
561 | "source": [
562 | "## Заключение\n",
563 | "\n",
564 | "Это руководство познакомило тебя с несколькими способами решения задач регрессии.\n",
565 | "\n",
566 | "Ключевые моменты урока:\n",
567 | "\n",
568 | "* Mean Squared Error (MSE) (пер. \"Среднеквадратическая ошибка\") - это распространенная функция потерь, используемая для решения задач регрессии (отличная от задач классификации)\n",
569 | "* Показатели оценки модели для регрессии отличаются от используемых в классификации\n",
570 | "* Когда входные данные имеют параметры в разных форматах, каждый параметр должен быть нормализован\n",
571 | "* Если данных для обучения немного, используй небольшую сеть из нескольких скрытых слоев. Это поможет избежать переобучения\n",
572 | "* Используй метод ранней остановки - это очень полезная техника для избежания переобучения"
573 | ]
574 | }
575 | ],
576 | "metadata": {
577 | "colab": {
578 | "collapsed_sections": [
579 | "FhGuhbZ6M5tl"
580 | ],
581 | "name": "basic-regression.ipynb",
582 | "private_outputs": true,
583 | "provenance": [],
584 | "toc_visible": true,
585 | "version": "0.3.2"
586 | },
587 | "kernelspec": {
588 | "display_name": "Python 3",
589 | "language": "python",
590 | "name": "python3"
591 | },
592 | "language_info": {
593 | "codemirror_mode": {
594 | "name": "ipython",
595 | "version": 3
596 | },
597 | "file_extension": ".py",
598 | "mimetype": "text/x-python",
599 | "name": "python",
600 | "nbconvert_exporter": "python",
601 | "pygments_lexer": "ipython3",
602 | "version": "3.6.2"
603 | }
604 | },
605 | "nbformat": 4,
606 | "nbformat_minor": 1
607 | }
608 |
--------------------------------------------------------------------------------
![](\"https://www.tensorflow.org/images/tf_logo_32px.png\"){kind=logo}
Смотрите на TensorFlow.org\n",
73 | " ![](\"https://www.tensorflow.org/images/colab_logo_32px.png\"){kind=logo}
Запустите в Google Colab\n",
76 | " ![](\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\")
Изучайте код на GitHub\n",
79 | " ![](\"https://www.tensorflow.org/images/download_logo_32px.png\"){kind=logo}
Скачайте ноутбук\n",
82 | "