Машинное обучение и нейронные сети - страница 67

Новый комментарий
 

2.3 K-ближайшие соседи (L02: методы ближайших соседей)



2.3 K-ближайшие соседи (L02: методы ближайших соседей)

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

Теперь давайте углубимся в подход k-ближайших соседей (k-NN), который является расширением метода одного ближайшего соседа, который мы обсуждали ранее. Модель k-NN относительно проста, поскольку она обобщает метод одного ближайшего соседа, рассматривая несколько ближайших соседей вместо одного.

В этом видео я представляю пример модели k-NN. У нас есть две функции, x1 и x2, и игрушечный набор данных с разными классами, представленными крестами, кружками и треугольниками. Наша цель — классифицировать точку данных, обозначенную вопросительным знаком в центре. Чтобы делать прогнозы, мы рассматриваем точки данных в пределах определенного радиуса вокруг вопросительного знака, используя евклидову меру расстояния.

Теперь возникает вопрос: каково будет значение k в этом подходе k-NN для данного примера? Если вы немного подумаете, вы поймете, что k равно 5, потому что мы рассматриваем пять ближайших точек данных к точке, которую мы хотим классифицировать.

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

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

Чтобы дать более формальное определение большинства голосов, давайте рассмотрим подмножество D sub k, которое представляет k ближайших соседей. Мы определяем большинство голосов как метку класса (y), которая максимизирует сумму дельта-функций. Дельта-функция возвращает 1, если a равно b (совпадающие метки), и 0 в противном случае. Суммируя значения дельты для каждого соседа, мы можем найти метку класса, которая встречается чаще всего.

Для регрессионного анализа с использованием k-NN процесс проще. Вместо меток классов мы имеем дело с непрерывными целевыми значениями. Прогноз (h) для регрессии k-NN представляет собой среднее значение целевых значений k ближайших соседей.

В следующем видео мы углубимся в тему анализа большого O, который включает в себя анализ сложности времени выполнения алгоритма k-ближайших соседей. Понимание эффективности алгоритма имеет решающее значение для оценки его производительности и масштабируемости. Анализ Big O позволяет оценить, как время выполнения алгоритма будет расти по мере увеличения размера входных данных. Этот анализ помогает нам принимать обоснованные решения о выборе и оптимизации алгоритма.

Чтобы выполнить анализ Big O для алгоритма k ближайших соседей, нам необходимо учитывать два основных фактора: количество обучающих экземпляров (n) и количество признаков (d). Эти факторы определяют вычислительные затраты на поиск k ближайших соседей для данной точки запроса.

В простейшей реализации k-ближайших соседей мы вычисляем расстояние между точкой запроса и каждым обучающим экземпляром, что приводит к временной сложности O (nd). Это означает, что время выполнения алгоритма растет линейно с количеством обучающих экземпляров и количеством признаков.

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

Используя эти структуры данных, мы можем сократить время поиска до O(log n) или даже O(1) в некоторых случаях. Это улучшение значительно ускоряет алгоритм, особенно для больших наборов данных.

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

Помимо временной сложности, мы также должны учитывать пространственную сложность алгоритма k ближайших соседей. Сложность пространства относится к объему памяти, необходимому для хранения обучающих экземпляров и любых дополнительных структур данных, используемых для эффективного поиска соседей. Объемная сложность обычно составляет O(nd) или O(n) для оптимизированных реализаций.

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

В следующем видео мы подробнее рассмотрим эти концепции и предоставим более подробный анализ эффективности алгоритма. Следите за подробным обсуждением анализа Big O для k ближайших соседей.

 

2.4 Большой O из K ближайших соседей (L02: методы ближайших соседей)



2.4 Большой O из K ближайших соседей (L02: методы ближайших соседей)

Теперь давайте углубимся в тему сложности времени выполнения, уделив особое внимание нотации Big O и сложности выполнения алгоритма k-ближайших соседей (KNN).

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

В случае KNN этап обучения включает в себя сохранение набора обучающих данных, что может потребовать большого объема памяти. Для хранения большого набора обучающих данных может потребоваться значительный объем оперативной памяти или места на жестком диске. Хотя пространство для хранения со временем стало дешевле, оно по-прежнему может создавать ограничения при работе с массивными наборами данных, такими как миллионы изображений.

Однако давайте переключим наше внимание на сложность KNN во время выполнения на этапе прогнозирования. Прежде чем мы продолжим, давайте кратко представим нотацию Big O. Это нотация, используемая для описания эффективности алгоритмов, обычно обозначаемая функциями. Эти функции представляют сложность алгоритмов во время выполнения, с общими примерами, включая O (1) (константа), O (log n) (логарифмическая) и так далее. Эти функции показывают, как время выполнения алгоритма масштабируется в зависимости от размера входных данных (n).

Чтобы лучше понять сложность времени выполнения, мы можем расположить функции в порядке возрастания эффективности, от O (1) до экспоненциальной сложности. В этом контексте константная функция идеальна, поскольку на нее не влияет размер входных данных, что обеспечивает постоянную скорость выполнения. Логарифмические и линейные функции также эффективны, хотя и не так идеальны, как постоянные функции. Однако по мере увеличения сложности до квадратичной, кубической и экспоненциальной эффективность алгоритма значительно ухудшается. Экспоненциальная сложность особенно вредна, и ее следует избегать, особенно при работе с большими наборами данных в машинном обучении.

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

Теперь давайте рассмотрим, как мы получаем нотацию Big O для данной функции. Например, рассмотрим квадратичную функцию f(x) = ax^2 + bx + c. При выводе нотации Big O мы ориентируемся на доминирующий член, который растет быстрее всего. В этом случае доминирующим членом является x ^ 2. Следовательно, нотация Big O для этой функции будет O (x ^ 2), что указывает на квадратичную сложность.

Давайте рассмотрим другую функцию, чтобы проиллюстрировать этот процесс дальше. Предположим, у нас есть функция f(x) = ax(log x). Опять же, мы определяем доминирующий термин, который равен x (log x). Здесь мы пренебрегаем постоянным фактором a и сосредоточиваемся на члене x (log x). Следовательно, нотация Big O для этой функции будет O (x log x), что указывает на логарифмическую сложность.

Стоит отметить, что основание логарифма (например, логарифмическое основание 2 или натуральный логарифм) не влияет на нотацию Big O. Различные базы вводят только коэффициент масштабирования, которым можно пренебречь при определении сложности выполнения. Поэтому для простоты мы обычно рассматриваем натуральный логарифм (log) без указания основания.

Чтобы еще больше укрепить ваше понимание, давайте рассмотрим функцию Python для умножения матриц, демонстрирующую применение нотации Big O к вычислительным алгоритмам. Функция выполняет матричное умножение между двумя матрицами, A и B. Хотя реализация намеренно неэффективна для иллюстрации, она позволяет нам проанализировать ее сложность во время выполнения.

Функция начинается с инициализации пустой матрицы C размера nxn, где n — размерность входных матриц. Затем он перебирает каждую строку i матрицы A и каждый столбец j матрицы B. Во вложенных циклах он вычисляет скалярное произведение строки i матрицы A и столбца j матрицы B, сохраняя результат в соответствующей ячейке матрицы матрица С.

Вот код Python для функции умножения матриц: 

def matrix_multiplication(A, B):
    n = len(A)  # Assuming square matrices of size n x n
    C = [[ 0 ] * n for _ in range(n)]  # Initialize matrix C
    
     for i in range(n):
         for j in range(n):
             for k in range(n):
                C[i][j] += A[i][k] * B[k][j]  # Calculate dot product and update C[i][j]
    
    return C
Чтобы проанализировать сложность этой функции во время выполнения, давайте разберем ее. Внешний цикл повторяется n раз, представляя строки матрицы A. Второй цикл также повторяется n раз, представляя столбцы матрицы B. Внутри этих циклов есть вложенный цикл, который также повторяется n раз, представляя вычисление скалярного произведения. Таким образом, общая сложность равна O(n^3), что указывает на кубическую сложность.

Важно отметить, что кубическая сложность не идеальна, особенно для больших значений n. По мере увеличения размера входных данных время выполнения этой функции значительно увеличивается. Следовательно, для больших матриц следует использовать более эффективный алгоритм для выполнения матричного умножения, такой как алгоритм Штрассена или другие оптимизированные подходы, которые обеспечивают лучшую сложность выполнения, например O (n ^ 2,81).

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

 

2.5 Улучшение k-ближайших соседей (L02: Методы ближайших соседей)



2.5 Улучшение k-ближайших соседей (L02: Методы ближайших соседей)

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

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

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

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

Точно так же алгоритм шарового дерева создает гиперсферы как разделы пространства. Выбор между деревьями KD и шаровыми деревьями зависит от характеристик набора данных. Для наборов данных с высокой размерностью часто предпочитают алгоритм шарового дерева. Стоит отметить, что библиотека машинного обучения scikit-learn, широко используемый инструмент, предлагает различные варианты алгоритма классификатора K-ближайших соседей, автоматически выбирая наиболее эффективный алгоритм разделения пространства на основе набора данных. Однако при желании вы можете вручную переопределить этот параметр.

Кроме того, мы можем повысить производительность K-ближайших соседей, используя методы уменьшения размерности. Снижение размерности происходит в двух вариантах: выделение признаков и выбор признаков. Извлечение признаков включает в себя преобразование или объединение существующих признаков для создания низкоразмерного представления данных. С другой стороны, выбор функций включает в себя выбор подмножества доступных функций без создания новых. Уменьшая количество признаков, мы можем снизить вычислительные затраты на вычисления расстояний и потенциально повысить эффективность алгоритма. Кроме того, многоразмерные наборы данных часто страдают от проклятия размерности, что может привести к плохой производительности обобщения из-за переобучения. Таким образом, уменьшение размерности также может помочь решить эту проблему.

Чтобы оптимизировать вычислительную производительность K-ближайших соседей, мы можем изучить методы редактирования или сокращения. Сокращение включает удаление ненужных точек данных из обучающего набора, не затрагивая границы решения. Устранив лишние точки, мы можем уменьшить количество сравнений и вычислений расстояний, сделав алгоритм более эффективным. Точно так же создание прототипов включает замену плотной области точек обучающих данных одной репрезентативной точкой. Эта стратегия снижает требования к объему памяти, сохраняя при этом точность прогнозирования алгоритма.

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

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

 

2.6 K-ближайших соседей в Python (L02: Методы ближайших соседей)



2.6 K-ближайших соседей в Python (L02: Методы ближайших соседей)

После всестороннего обсуждения K-ближайших соседей текст переходит к представлению примера Python, который демонстрирует реализацию K-ближайших соседей с использованием популярной библиотеки scikit-learn. Автор признает, что не все аспекты могут быть сразу ясны, и уверяет читателей, что в следующих лекциях будут более подробно рассмотрены Python, NumPy и scikit-learn. Тем не менее, приведенный пример служит тизером, чтобы предложить взгляд сверху вниз на то, как работают эти инструменты.

Чтобы поддержать пример реализации, автор ссылается на веб-сайт, где читатели могут найти примеры кода. Кроме того, автор объясняет процесс загрузки репозитория с GitHub с помощью zip-файла или его клонирования. Подчеркивая значение GitHub как инструмента реального мира, автор предполагает, что наличие профиля GitHub и обмен проектами может быть полезным для демонстрации своей работы потенциальным работодателям.

Далее в тексте приводятся подробные инструкции о том, как клонировать репозиторий с помощью ссылки GitHub и команды «git clone». Признавая, что процесс может немного отличаться для пользователей Windows, автор рекомендует обратиться за помощью к ассистенту преподавателя или обучающим материалам. После успешного клонирования репозитория автор предлагает читателям перейти в папку и объясняет, что обновления можно получить с помощью команды «git pull».

Переходя к примерам кода, автор демонстрирует открытие Jupyter Notebook, в частности Jupyter Lab, и пошаговое выполнение команд. Чтобы не перегружать читателей, автор подчеркивает важность очистки выходных данных после каждого выполнения. Кроме того, автор упоминает полезность расширения водяного знака в Jupyter Notebooks, которое отображает версии используемых программных пакетов. Эта информация помогает в устранении неполадок и обеспечивает воспроизводимость результатов. Основные пакеты, такие как Pandas, NumPy, Matplotlib и scikit-learn, устанавливаются для облегчения реализации.

Затем автор загружает набор данных Iris из файла CSV и демонстрирует использование таких команд, как «голова» и «хвост», для предварительного просмотра набора данных. Данные загружаются в Pandas DataFrame с помощью функции «read_csv». Отмечая, что машинное обучение обычно использует массивы NumPy, автор подчеркивает, что scikit-learn также поддерживает DataFrames. Чтобы проиллюстрировать это, автор приводит пример извлечения определенных столбцов из DataFrame для создания массива NumPy. Форма массива, указывающая количество обучающих примеров и признаков, отображается с помощью команды «shape».

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

  1. Перетасовка индексов и меток: автор инициирует рабочий процесс, обсуждая процесс перетасовки индексов и меток в наборе данных. Цель перетасовки — рандомизировать порядок точек данных, гарантируя, что каждая метка соответствует правильной строке в матрице признаков.

  2. Разделение набора данных: набор данных разделен на обучающий набор и тестовый набор. Автор вручную отбирает первые 105 примеров для обучающего набора, а оставшиеся 45 примеров резервирует для тестового набора. Это разделение имеет решающее значение для оценки производительности модели машинного обучения.

  3. Введение в scikit-learn и набор данных Iris: автор представляет библиотеку scikit-learn, в частности реализацию набора данных Iris и функцию «train_test_split». Набор данных Iris — популярный набор данных, широко используемый для задач классификации. Функция «train_test_split» автоматически перемешивает набор данных и разбивает его на указанные пропорции для обучения и тестирования.

  4. Визуализация с использованием матрицы диаграммы рассеяния. Автор предоставляет удобную функцию под названием «матрица диаграммы рассеяния» для визуализации набора данных. Эта функция использует библиотеку matplotlib для создания матрицы диаграммы рассеяния с гистограммами, отображаемыми по диагонали. Матрица диаграммы рассеяния визуально представляет отношения между различными функциями в наборе данных.

  5. Демонстрация матрицы диаграммы рассеяния: автор демонстрирует использование матрицы диаграммы рассеяния, строя набор данных Iris. Различные цвета назначаются для представления разных классов цветов. Примечательно, что автор подчеркивает, что определенные признаки, такие как длина лепестков и ширина лепестков, особенно полезны для различения разных классов цветков.

  6. Введение в классификатор k-ближайших соседей (k-NN): автор переходит к объяснению классификатора k-ближайших соседей (k-NN), который представляет собой простой алгоритм, который классифицирует точки данных на основе их близости к соседним точкам данных. Чтобы создать экземпляр классификатора k-NN, автор создает объект с тремя соседями.

  7. Подгонка классификатора k-NN: классификатор k-NN подгоняется к тренировочному набору с использованием метода «подгонки». На этом шаге модель обучается с использованием предоставленных обучающих данных.

  8. Прогноз на тестовом наборе: автор использует подобранный классификатор k-NN, чтобы делать прогнозы на тестовом наборе с использованием метода «предсказания». Прогнозы хранятся в переменной с именем «пред».

  9. Оценка производительности: чтобы оценить производительность модели, автор сравнивает предсказанные метки (хранящиеся в «пред») с истинными метками тестового набора (хранящиеся в «y_test»). Подсчитав количество правильных прогнозов, можно определить точность модели на тестовом наборе.

  10. Заключение и дальнейшее исследование: лекция завершается призывом к читателям изучить документацию scikit-learn для получения дополнительной информации об алгоритме k-ближайших соседей и его различных вариантах. Кроме того, автор задает читателям вопрос относительно метрики расстояния по умолчанию, используемой классификатором k-NN, и предлагает упражнение для изучения и обсуждения этого аспекта.

Лекция дает исчерпывающее объяснение различных тем, включая концепцию K-ближайших соседей, пример реализации с использованием библиотеки scikit-learn, рекомендации по загрузке и клонированию репозиториев с GitHub, введение в Jupyter Notebook и Jupyter Lab, загрузку набора данных. в Pandas DataFrame и демонстрирует извлечение столбцов и преобразование в массивы NumPy.

 

3.1 (Факультативный материал) Обзор Python



3.1 (Факультативный материал) Обзор Python

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

Во-первых, у нас была лекция об улучшении Canaan, за которой последовала лекция о реализации kin в Python с использованием экстрасенсорного обучения. Основываясь на ваших отзывах о вступлении к викторине «Знакомство с вами», я обнаружил, что у большинства из вас есть опыт программирования или они ранее посещали курсы программирования. Это отличная новость, потому что этот курс будет очень полезен для вас. Однако я заметил, что только половина из вас имеет солидный опыт работы с Python. Поэтому, прежде чем мы углубимся в научные вычисления с помощью Python и более подробно изучим экстрасенсорное обучение, я подумал, что было бы полезно оказать некоторую помощь в настройке Python для тех, кто не знаком с ним. Это гарантирует, что следующая лекция пройдет более гладко для всех.

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

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

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

Прежде чем мы продолжим, давайте кратко рассмотрим ход курса. На первой неделе мы рассмотрели введение в машинное обучение и K-ближайших соседей. В настоящее время мы находимся на второй неделе, сосредотачиваясь на вычислительных основах. Эти основы имеют решающее значение, поскольку позже мы будем использовать их для реализации различных концепций машинного обучения. Поэтому очень важно заранее ознакомиться с Python и его использованием. В этой лекции мы в первую очередь обсудим Python и его настройку. Обратите внимание, что я буду демонстрировать процесс установки на своем Mac, но наш ассистент может помочь с любыми вопросами, связанными с Windows.

Python — это интерпретируемый и динамический язык программирования, что делает его более интерактивным и удобным для пользователя по сравнению с языками со статической типизацией, такими как C или C++. Хотя Python может быть медленнее, чем эти языки, для наших целей это не имеет большого значения. Многие библиотеки научных вычислений, которые мы рассмотрим в следующей лекции, написаны на C или Fortran и предлагают быстрое время выполнения. Python — это универсальный язык программирования, широко используемый в различных приложениях, включая такие веб-фреймворки, как Django, и популярные сервисы, такие как Instagram и Dropbox.

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

#include <stdio.h>

int main() {
     int age = 25 ;
     float height = 1.75 ;
     char initial = 'J' ;

    printf( "My age is %d\n" , age);
    printf( "My height is %.2f meters\n" , height);
    printf( "My initial is %c\n" , initial);

     return 0 ;
}
В этой программе на C мы объявили переменные age, height и initial с соответствующими типами данных. Затем мы присвоили значения этим переменным и распечатали их с помощью функции printf().

Теперь давайте сравним ту же программу на Python: 

age = 25
height = 1.75
initial = 'J'

print( "My age is" , age)
print( "My height is" , height, "meters" )
print( "My initial is" , initial)
В Python вам не нужно явно объявлять типы переменных. Вы можете напрямую присваивать значения переменным, и Python автоматически определит типы данных. Функция print() используется для отображения вывода.

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

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

  1. Посетите веб-сайт Anaconda ( https://www.anaconda.com/products/individual ) и загрузите программу установки, подходящую для вашей операционной системы (Windows, macOS или Linux).

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

  3. После завершения установки на вашем компьютере должны быть установлены Anaconda Navigator и Anaconda Prompt (или Anaconda PowerShell Prompt). Это удобные инструменты для управления средами и пакетами Python.

  4. Откройте Anaconda Navigator и перейдите на вкладку «Среды». Здесь вы можете создать новую среду для этого курса. Нажмите кнопку «Создать», укажите имя среды (например, «машинное обучение») и выберите версию Python (предпочтительно Python 3.x). Нажмите «Создать», чтобы создать среду.

  5. После создания среды щелкните вкладку «Главная» в Anaconda Navigator. Вы должны увидеть список доступных приложений и сред. Выберите только что созданную среду в раскрывающемся меню в верхней части окна.

  6. На вкладке «Главная» нажмите кнопку «Установить» в разделе Jupyter Notebook. Это установит Jupyter Notebook, который мы будем использовать для интерактивного программирования и запуска кода Python.

  7. После установки нажмите кнопку «Запустить» рядом с Jupyter Notebook. Откроется новая вкладка в вашем веб-браузере с Jupyter Notebook.

Поздравляем! Вы успешно установили Python и Jupyter Notebook, используя дистрибутив Anaconda. Теперь вы готовы начать кодирование на Python для этого курса. В следующей лекции мы углубимся в научные вычисления с помощью Python и изучим популярную библиотеку под названием scikit-learn.

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

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

Free Download | Anaconda
  • www.anaconda.com
Everything you need to get started in data science on your workstation. Free distribution install Thousands of the most fundamental DS, AI, and ML packages Manage packages and environments from desktop application Deploy across hardware and software platforms
 

3.2 (Факультативный материал) Настройка Python


3.2 (Факультативный материал) Настройка Python

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

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

Для начала рекомендуется проверить, установлена ли у вас на компьютере уже актуальная версия Python. В Mac или Linux вы можете использовать команду «какой Python», чтобы определить место установки и версию. Точно так же в Windows вы можете использовать команду «где», чтобы найти место установки.

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

Официальным методом установки Python является посещение python.org и загрузка установщика. Однако альтернативным подходом, который часто предпочтительнее, является использование Anaconda или, точнее, Miniconda. Miniconda — это облегченная версия Anaconda, не содержащая ненужных библиотек, что позволяет экономить место на вашем компьютере. В то время как Anaconda поставляется с предустановленными библиотеками, Miniconda обеспечивает более индивидуальный процесс установки.

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

Чтобы установить Miniconda, вы можете посетить веб-сайт документации, docs.conda.io, и перейти к последней английской версии страницы установки Miniconda. Оттуда вы можете выбрать подходящий установщик для вашей операционной системы. Для пользователей Mac обычно используется установщик bash. После загрузки установщика запустите скрипт, примите лицензионное соглашение и выберите место установки.

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

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

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

Помните, что вы также можете обновлять пакеты с помощью диспетчера пакетов Conda, используя такие команды, как «conda update», за которыми следует имя пакета, или с помощью «pip», используя «pip install --upgrade», за которым следует имя пакета.

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

Чтобы установить пакеты с канала Conda Forge, вы можете использовать следующую команду:

conda install -c conda-forge <имя-пакета>

Например, чтобы установить пакет MLX Extent из Conda Forge, вы должны использовать:

conda установить -c conda-forge mlx_ext

Эта команда выполнит поиск пакета в канале Conda Forge и установит его в вашу среду.

Если нужный вам пакет недоступен в Conda Forge или любом другом канале Conda, вы также можете установить его с помощью диспетчера пакетов pip. Pip — это менеджер пакетов по умолчанию для Python, который позволяет устанавливать пакеты из индекса пакетов Python (PyPI).

Чтобы установить пакет с помощью pip, вы можете использовать следующую команду:

pip install <имя-пакета>

Например, чтобы установить пакет с именем «example-package» с помощью pip, вы должны использовать:

Пример установки pip-пакета

Обязательно замените <package-name> на фактическое имя пакета, который вы хотите установить.

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

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

 

3.3 (Факультативный материал) Запуск кода Python


3.3 (Факультативный материал) Запуск кода Python

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

Прежде чем погрузиться в блокноты Jupiter, я сначала покажу вам самый простой способ запуска кода Python, который использует интерпретатор Python или то, что некоторые люди называют REPL (цикл чтения-оценки-печати). Интерпретатор позволяет интерактивно выполнять код Python, что означает, что код оценивается немедленно. Чтобы использовать интерпретатор, вы можете открыть свой терминал и ввести «python». Оттуда вы можете вводить выражения Python и сразу же просматривать результаты. Например, при вводе «print(1 + 2)» будет отображаться результат «3». Вы также можете использовать интерпретатор для более сложных задач, таких как циклическое перебор значений и их печать.

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

Далее я представляю альтернативный интерактивный интерпретатор Python под названием IPython. IPython предлагает дополнительные функции и функции по сравнению с обычным интерпретатором, включая подсветку синтаксиса, функцию истории для легкой модификации кода и магические команды. Волшебные команды — это специальные команды, которые начинаются со знака процента (%) и предоставляют полезные функции. Одним из таких примеров является волшебная команда «timeit», которая позволяет проводить бенчмаркинг различных реализаций кода. Я демонстрирую это, реализуя две функции для обращения строк и сравнивая их эффективность с помощью команды «timeit».

После демонстрации преимуществ IPython я поясню, что блокноты Jupiter изначально назывались блокнотами IPython, потому что они были созданы на основе IPython. Даже сейчас ноутбуки Jupiter полагаются на IPython, предоставляя те же преимущества и дополнительные функции. Чтобы установить IPython, я использую Conda и показываю веб-сайт IPython для получения дополнительной документации.

Двигаясь дальше, я расскажу о втором методе выполнения кода Python, который использует скрипты Python. Этот метод включает создание файла с расширением .py, написание кода в файле и выполнение его из командной строки. Я привожу пример скрипта Python, который использует цикл для вывода чисел от 0 до 4.

Наконец, я упоминаю о важности соблюдения рекомендаций по стилю кодирования, таких как PEP 8, для написания чистого и читаемого кода. Я покажу, как использование линтера, такого как Flake8, в интегрированной среде разработки, такой как Visual Studio Code, может помочь выявить и исправить проблемы со стилем, повысив общее качество кода.

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

 

4.1 Введение в NumPy (L04: Научные вычисления в Python)



4.1 Введение в NumPy (L04: Научные вычисления в Python)

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

Для начала нам нужно импортировать библиотеку NumPy. Обычно он импортируется под псевдонимом np. Запустите следующий код, чтобы импортировать NumPy: 

import numpy as np
Теперь, когда мы импортировали NumPy, давайте создадим наш первый массив. Массивы NumPy создаются с помощью функции np.array(), которая принимает список Python в качестве входных данных. Запустите следующий код, чтобы создать массив: 

arr = np.array([1, 2, 3, 4, 5])
print(arr)
Вы должны увидеть следующий вывод: 

[1 2 3 4 5]
Поздравляем! Вы создали свой первый массив NumPy. Теперь давайте рассмотрим некоторые основные операции, которые мы можем выполнять с массивами.

Доступ к элементам массива

Чтобы получить доступ к элементам в массиве NumPy, мы можем использовать индексирование и нарезку, подобно спискам Python. Индексация начинается с 0.

Запустите следующий код для доступа к элементам массива:

 print (arr[ 0 ])   # Access the first element
print (arr[ 2 ])   # Access the third element
print (arr[- 1 ])   # Access the last element
Вывод будет: 

1
3
5
Мы также можем использовать нарезку для доступа к ряду элементов в массиве. Синтаксис для нарезки: start:stop:step, где start — начальный индекс, stop — конечный индекс (исключающий), а step — размер шага.

Запустите следующий код, чтобы разрезать массив:

 print (arr[ 1 : 4 ])   # Access elements from index 1 to 3
print (arr[:: 2 ])   # Access every other element
Вывод будет: 

[2 3 4]
[1 3 5]
Операции с массивами

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

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

arr1 = np. array ([ 1 , 2 , 3 ])
arr2 = np. array ([ 4 , 5 , 6 ])

# Addition
print (arr1 + arr2)

# Subtraction
print (arr1 - arr2)

# Multiplication
print (arr1 * arr2)

# Division
print (arr1 / arr2)
Вывод будет: 

 [5 7 9]
[-3 -3 -3]
[4 10 18]
[0.25 0.4  0.5]
NumPy также предоставляет различные математические функции, которые можно применять к массивам. Например, функцию np.sin() можно использовать для вычисления синуса массива.

Запустите следующий код, чтобы применить математическую функцию к массиву: 

arr = np. array ([ 0 , np.pi/ 2 , np.pi])

# Calculate sine
print (np.sin(arr))
Вывод будет: 

[0.0000000e+00 1.0000000e+00 1.2246468e-16]

Форма массива и изменение формы

Форма массива NumPy представляет его размеры, такие как количество строк и столбцов. Мы можем использовать атрибут shape для проверки формы массива.

Запустите следующий код, чтобы проверить форму массива: 

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.shape)
Вывод будет: 

(2, 3)
Мы также можем изменить форму массива с помощью функции reshape(). Эта функция позволяет нам изменять размер массива без изменения его данных.

Запустите следующий код, чтобы изменить форму массива: 

arr = np.array([1, 2, 3, 4, 5, 6])
reshaped_arr = arr.reshape((2, 3))
print(reshaped_arr)
Вывод будет: 

[[1 2 3]
 [4 5 6]]
Это лишь некоторые из основных операций, которые вы можете выполнять с помощью NumPy. Библиотека предоставляет широкий набор функций и возможностей для эффективной работы с массивами. Я рекомендую вам изучить документацию NumPy, чтобы узнать больше о его функциях.
 

4.2 Построение и индексирование массива NumPy (L04: Научные вычисления в Python)



4.2 Построение и индексирование массива NumPy (L04: Научные вычисления в Python)

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

Чтобы создать массив, заполненный числом один, мы можем использовать функцию единиц. Например, one((3, 3)) сгенерирует массив 3x3, в котором все элементы равны единице. Вы также можете указать другие размеры, например, единицы ((3, 4)), которые создадут матрицу 3x4, заполненную единицами. Функция one принимает различные аргументы, в том числе параметр dtype, определяющий тип данных массива (по умолчанию — float64 для 64-битных машин). Вы можете установить его в int64, чтобы создать массив целых чисел. Кроме того, вы можете указать параметр порядка, который управляет расположением массива в памяти. По умолчанию используется C, представляющий построчный стиль, но вы можете выбрать F для макета в стиле Fortran. Однако для этого класса вам не нужно беспокоиться об этих деталях, так как они больше подходят для объединения NumPy с кодом C или Fortran.

Точно так же функцию zeros можно использовать для создания массива, заполненного нулями. Вы можете использовать его так же, как и one. Помните, что если вы хотите узнать больше об этих функциях, вы можете использовать функцию справки или знак вопроса (?) в Jupyter Lab или IPython.

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

Переходя к индексации, базовая индексация в массивах NumPy аналогична индексации в списках Python. Вы можете получить доступ к элементам, используя квадратные скобки. Например, array[0] возвращает первый элемент, array[1] возвращает второй элемент и так далее. Нарезка также возможна, как и со списками Python. Например, array[1:4] вернет фрагмент массива от индекса 1 до индекса 3 (за исключением индекса 4).

При работе с двумерными массивами вы можете использовать запятую для индексации двух измерений. Первый индекс указывает строку, а второй индекс указывает столбец. Например, array[0, 0] возвращает элемент из первой строки и первого столбца, array[1, 2] возвращает элемент из второй строки и третьего столбца и так далее.

Отрицательное индексирование можно использовать для доступа к элементам с конца массива. Например, array[-1, -1] вернет последний элемент массива. Точно так же array[-1, -2] вернет предпоследний элемент. Это может быть полезно при работе с большими массивами, так как вам не нужно отслеживать длину массива.

Чтобы получить всю строку или столбец, вы можете опустить один из индексов. Например, array[0, :] возвращает всю первую строку, а array[:, 1] возвращает весь второй столбец. Это эквивалентно указанию диапазона индексов (например, array[0, 0:3] для первой строки). Нарезка работает в обоих измерениях, позволяя выбирать определенные части массива. Например, array[1:3, 2:4] возвращает подмассив, состоящий из строк 1 и 2 (исключая строку 3) и столбцов 2 и 3 (исключая столбец 4).

Логическое индексирование — еще одна мощная функция NumPy. Вы можете использовать логический массив для индексации массива, выбирая только те элементы, которые соответствуют значениям True в логическом массиве. Например, предположим, что у нас есть массив с именем array формы (3, 3): 

array( [[1, 2, 3] ,
       [4, 5, 6] ,
       [7, 8, 9] ])
Мы можем создать логический массив на основе условия, такого как массив > 5, который вернет следующий логический массив: 

array([[ False , False , False ],
       [ False , False , True ],
       [ True , True , True ]])
Используя этот логический массив в качестве индекса для исходного массива, мы можем выбрать только те элементы, которые соответствуют значениям True, в результате чего: 

array([6, 7, 8, 9])
Логическое индексирование позволяет гибко и эффективно выбирать элементы на основе конкретных условий.

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

 

4.3 Математика массива NumPy и универсальные функции (L04: Научные вычисления в Python)



4.3 Математика массива NumPy и универсальные функции (L04: Научные вычисления в Python)

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

Универсальные функции, часто сокращенно называемые Ufunk или Frank, представляют собой мощное понятие в программировании. Универсальная функция (Ufunk) — это сокращенная форма универсальной функции, позволяющая более эффективно и удобно работать с массивами Numpy. Он вводит концепцию, называемую векторизацией.

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

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

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

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

В Numpy мы можем использовать Ufunk «np.add», чтобы добавить число 1 ко всему массиву в векторной форме. Это устраняет необходимость в явных циклах и значительно повышает производительность.

Стоит отметить, что Numpy использует перегрузку операторов, что позволяет интуитивно использовать Ufunk. Например, использование оператора «+» между массивом и числом автоматически вызывает Ufunk «np.add».

Еще одним полезным Ufunk является «np.square», который возводит в квадрат каждый элемент массива. Функции Ufunk могут быть унарными (действующими с одним значением) или бинарными (принимающими два аргумента). Официальная документация Numpy содержит более подробную информацию о доступном Ufunk.

Переходя к более интересному случаю, давайте рассмотрим использование Ufunk в сочетании с методом «reduce». Операция «уменьшить» применяет операцию вдоль указанной оси, сводя несколько значений к одному значению. Например, мы можем вычислить суммы столбцов, используя «np.add» с методом «reduce».

В этом сценарии мы прокручиваем указанную ось (в данном случае ось 0) и объединяем элементы с помощью указанной операции. Операция «сокращение» обычно ассоциируется с такими понятиями, как «уменьшение карты» и Hadoop, где вычисления распределяются между несколькими узлами, а затем объединяются для получения конечного результата.

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

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

Итак, в NumPy у нас есть функция, называемая сокращением, которая позволяет нам выполнять операции сокращения вдоль заданной оси массива. Операция редукции объединяет несколько значений в одно значение. По умолчанию уменьшение применяется по первой оси (ось 0) массива.

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

array( [[1, 2, 3] ,
       [4, 5, 6] ,
       [7, 8, 9] ])
Если мы хотим вычислить суммы столбцов, мы можем использовать функцию сокращения. Эта операция прокрутит первую ось (ось 0) и объединит значения в каждом столбце. Итак, результатом будет одномерный массив, содержащий суммы по каждому столбцу.

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

Вот как выглядит код: 

import numpy as np

array = np. array ([[ 1 , 2 , 3 ],
                  [ 4 , 5 , 6 ],
                  [ 7 , 8 , 9 ]])

column_sums = np.reduce(np.add, array )
print (column_sums)
Вывод будет: 

[12 15 18]
В этом примере функция сокращения перебирает столбцы массива и складывает значения вместе. Он объединяет первый столбец (1 + 4 + 7), второй столбец (2 + 5 + 8) и третий столбец (3 + 6 + 9) в один массив, представляющий суммы столбцов.

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

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

1...606162636465666768697071727374
Новый комментарий
Причина обращения: