精华内容
下载资源
问答
  • 机器人学机器学习与控制介绍(Introduction) At some point in a machine learning project, you will want to overcome the limitations of your local machine (number of cores, memory, etc.), whether you want ...

    机器人学机器学习与控制

    介绍(Introduction)

    At some point in a machine learning project, you will want to overcome the limitations of your local machine (number of cores, memory, etc.), whether you want to generate a large amount of data to feed deep learning networks or train your algorithms as fast as possible. In this article, we will take you on a journey, sharing the difficulties and the solutions we found, from naive implementation to more advanced techniques, taking advantage of the various computational resources that may be found in the Cloud. We hope this will help you to efficiently manage and improve your productivity for your machine learning projects.

    在机器学习项目中的某个时刻,无论您是要生成大量数据来馈入深度学习网络还是要训练算法,您都将要克服本地机器的限制(内核,内存等)。尽可能快地。 在本文中,我们将带您走上一段旅程,分享从天真的实现到更先进的技术所遇到的困难和解决方案,并利用云中可能发现的各种计算资源。 我们希望这将帮助您有效地管理和提高机器学习项目的生产率。

    生成大量数据(例如……很多!) (Generating numerous chunks of data (like… A lot!))

    For our experiment, we want to be able to generate a large amount (let’s say 1,000,000) of chunks of data, in a few minutes, to serve as inputs for some Generative Adversarial Networks (GANs). If you have never heard of GANs, you can read my introductory article here [1].

    对于我们的实验,我们希望能够在几分钟之内生成大量(比如说1,000,000 )数据块,以作为某些生成对抗网络(GAN)的输入。 如果您从未听说过GAN,可以在这里阅读我的介绍性文章[1]。

    The chunks we are talking about will be cubes of dimension n=100 (i.e. 1,000,000 of data points). This specific number of 1 megavoxels (data points for volumes) has been chosen to match the current state of the art of generating fake faces, that can be seen on the website thispersondoesnotexist.com. The technique used there is called StyleGAN2 [2] (a variant of GANs), where generated images are of size 1024 x 1024, thus on the order of magnitude of 1 megapixels.

    我们正在讨论的块将是尺寸为n = 100(1,000,000个数据点)的多维数据集。 已选择此特定数量的1兆体素(体积的数据点),以匹配生成假脸的当前技术水平,这可以在thispersondoesnotexist.com网站上看到。 那里使用的技术称为StyleGAN2 [2](GAN的变体),其中生成的图像大小为1024 X 1024,因此约为1兆像素

    In order to reflect some data preparation from the real world, additional constraints will apply to build our cubes. They will be derived from dataframes and will be the result of stacking numpy arrays. For the sake of simplicity, those dataframes will have random values.

    为了反映来自现实世界的一些数据准备,附加的约束将应用于构建我们的多维数据集。 它们将从数据帧派生,并且是堆叠numpy数组的结果。 为了简单起见,这些数据帧将具有随机值。

    The objective here is to create cubes as fast as possible !

    这里的目标是尽可能快地创建多维数据集!

    The first steps will be done on our local machine, which specs are described in Table 1. As you can see, this is already a pretty nice setup.

    第一步将在我们的本地计算机上完成,其规格在表1中进行了描述您可以看到,这已经是非常不错的设置。

    Image for post
    Table 1: Specifications of our local machine.
    表1:我们本地机器的规格。

    输入数据 (Input Data)

    We first generate 100 dataframes of size 1000 x 1000, containing random floats (rounded to 10 decimals), thanks to the numpy.random.rand function. The dataframes are then saved to disk using the pandas.DataFrame.to_csv function. Each csv file is about 13 Mo.

    我们首先生成大小为1000的100个数据帧 X 1000,由于numpy.random.rand函数,包含随机浮点数(四舍五入到10位小数)。 然后使用pandas.DataFrame.to_csv函数将数据帧保存到磁盘。 每个csv文件约为13Mo。

    For each cube, we will have to use all the dataframes to extract a random subset from them. Using the pandas.read_csv function, it takes 20.87s to read all the dataframes, hence 4.79 files/s. This is very slow. For the record, if we wanted to build 1,000,000 cubes, at this pace, it would take more than 240 days !

    对于每个多维数据集,我们将不得不使用所有数据帧从中提取随机子集。 使用pandas.read_csv函数,读取所有数据帧需要20.87秒,因此需要4.79个文件/秒。 这很慢。 记录下来,如果我们要以这种速度建造1,000,000个多维数据集,则将需要240天以上的时间

    Instead of using the csv format, let’s consider the parquet file format to save our dataframes. Using the fastparquet engine [3], each saved parquet file is now only 8 Mo. If you want to learn more about the parquet file format, you can check the official website here [4]. This time, reading all the 100 dataframes only takes 6.57s (or 15.21 files/s)! This represents a 3.2x speedup. Those first results are gathered in Table 2.

    让我们考虑使用实木复合地板文件格式来保存数据帧,而不是使用csv格式。 现在,使用fastparquet引擎[3],每个保存的实木复合地板文件只有8Mo 。如果您想了解有关实木复合地板文件格式的更多信息,可以在此处查看官方网站[4]。 这次,读取所有100个数据帧仅需6.57 s (或15.21个文件/ s)! 这表示加速了3.2倍。 这些最初的结果汇总在表2中

    Image for post
    Table 2: Reading speed comparison, csv versus parquet (100 files).
    表2:csv与镶木地板的读取速度比较(100个文件)。

    建立我们的第一个立方体 (Building Our First Cubes)

    Image for post
    Photo by Max Henk on Unsplash
    Max HenkUnsplash拍摄的照片

    Using some constraints, the following steps will apply to build one cube:

    使用一些约束,以下步骤将应用于构建一个多维数据集:

    1. For each dataframe, we extract a sub-dataframe containing the first 100 rows and 100 random columns,

      对于每个数据框,我们提取一个子数据框,其中包含前100行和100个随机列,
    2. Each sub-dataframe is then converted to a numpy array of dimension 100 x 100,

      然后将每个子数据帧转换为尺寸为100 x 100的numpy数组,

    3. The numpy arrays are stacked to create one cube.

      numpy数组堆叠以创建一个多维数据集。

    # CREATING THE CUBES FROM FILES (READ IN A LOOP)import numpy as np
    import pandas as pdncubes = 100
    dim = 100for n in range(ncubes):
    cube = np.zeros(shape=(dim, dim, dim))
    # 'files_list' is the list of the parquet file paths
    for i, f in enumerate(files_list):
    df = pd.read_parquet(f)
    df = df.head(dim)
    rnd_cols = random.sample(range(1, df.shape[1]), dim)
    df = df.iloc[:, rnd_cols]
    layer = df.to_numpy()
    cube[i, :, :] = layer

    The total time to get a batch of 100 cubes is about 661s (almost 11 minutes), hence a rate of 0.15 cubes/s.

    一批100立方的总时间约为661s(将近11分钟),因此速率为0.15立方/秒

    I’m sure you already spotted the mistake here. Indeed, for each cube, we read the same 100 parquet files every time! In practice, you surely don’t want to loop over those files. The next improvement regarding the data structure is going to fix this.

    我确定您已经在这里发现了错误。 实际上,对于每个多维数据集,我们每次都读取相同的100个实木复合地板文件! 实际上,您当然不希望遍历这些文件。 关于数据结构的下一个改进将解决此问题。

    提高速度-步骤1:数据结构 (Improving Speed — Step 1: The Data Structure)

    Image for post
    Photo by Fezbot2000 on Unsplash
    Fezbot2000Unsplash上的 照片

    Since we don’t want to read the parquet files inside the loop for each cube, it could be a good idea to perform this task only once and upfront. So, we can build a dictionary df_dict, having files names as keys and dataframes as values. This operation is pretty fast and the dictionary is built in 7.33s only.

    由于我们不想在每个多维数据集的循环内读取镶木地板文件,因此最好一次只执行一次此任务。 因此,我们可以构建字典df_dict ,将文件名作为键,将数据帧作为值。 此操作非常快,并且字典仅在7.33s内构建。

    Now, we are going to write a function to create a cube, taking advantage of that dictionary already having dataframes read and stored as its own values.

    现在,我们将编写一个函数来创建一个多维数据集,利用该字典已经读取和存储了自己的值的数据帧。

    # FUNCTION CREATING A CUBE FROM A DICTIONARY OF DATAFRAMESdef create_cube(dimc, dict_df):
    cube = np.zeros(shape=(dimc, dimc, dimc))
    for i, df in enumerate(dict_df.values()):
    df = df.head(dimc)
    rnd_cols = random.sample(range(1, df.shape[1]), dimc)
    df = df.iloc[:, rnd_cols]
    layer = df.to_numpy()
    cube[i, :, :] = layer
    return cube

    This time, creating 100 cubes only took 6.61s for a rate of 15.13 cubes/s. This represents a 100x speedup compared to the previous version not using the dictionary of dataframes. Creating our batch of 1,000,000 cubes would now only take nearly 20 hours instead of the initial 240 days.

    这次,创建100个多维数据集仅花费了6.61秒,速率为15.13多维数据集/秒。 与不使用数据帧字典的先前版本相比,这代表了100倍的加速。 现在,创建我们的1,000,000多维数据集批次仅需将近20小时,而不是最初的240天。

    Now, we still use dataframes to build our cubes, maybe it’s time to go full NumPy to increase our speed.

    现在,我们仍然使用数据框构建多维数据集,也许是时候使用完整的NumPy来提高速度了。

    提高速度-步骤2:NumPy摇滚! (Improving Speed — Step 2: NumPy Rocks!)

    Image for post
    Hanson Lu on 汉森路Unsplash Unsplash

    The previous idea of using a dictionary of dataframes was interesting but may be improved by building, from the very beginning, a numpy.ndarray derived from the parquet files, from which we will sub-sample along the columns to create our cubes. Let’s first create this big boy:

    以前使用数据帧字典的想法很有趣,但是可以通过从一开始构建从numpy.ndarray文件派生的numpy.ndarray加以改进,然后我们将沿着列对它们进行子采样以创建多维数据集。 首先创建一个大男孩:

    # CREATING THE RAW DATA (NUMPY FORMAT)arr_data = np.zeros(shape=(100, 1000, 1000))
    # 'files_list' is the list of the parquet file paths
    for i, j in enumerate(files_list):
    df = pd.read_parquet(j)
    layer = df.to_numpy()
    arr_data[i, :, :] = layer

    Then, we have to modify our create_cube function accordingly and implement a full vectorization:

    然后,我们必须相应地修改create_cube函数并实现完整的矢量化:

    # FUNCTION CREATING A CUBE FROM RAW DATA (FULL NUMPY VERSION)def create_cube_np(dimc):
    rnd_cols = random.sample(range(1, 1000), dimc)
    # First 100 rows, 100 random columns (vectorization)
    cube = arr_data[:, :100, rnd_cols]
    return cube

    Using this new version, we are able to create 100 cubes in just 1.31s, hence a nice rate of 76.26 cubes/s.

    使用这个新版本,我们能够在1.31s内创建100个多维数据集,因此速率为76.26 cubes / s

    Now, we can move on to the next step to go even faster. You guessed it, time for parallelization!

    现在,我们可以继续下一步以更快地进行操作。 您猜对了,该进行并行化了

    提高速度-步骤3:并行化 (Improving Speed — Step 3: Parallelization)

    Image for post
    Photo by Marc-Olivier Jodoin on Unsplash
    Marc-Olivier JodoinUnsplash拍摄的照片

    There are several ways to perform parallelization in Python [5][6]. Here, we will use the native multiprocessing Python package along with the imap_unordered function to perform asynchronous jobs. We plan to take advantage of the 12 cores from our local machine.

    在Python [5] [6]中有几种执行并行化的方法。 在这里,我们将使用本机multiprocessing Python包以及imap_unordered函数来执行异步作业。 我们计划利用本地计算机的12个内核。

    # PARALLELIZATIONfrom multiprocessing import ThreadPoolproc = 12  # Number of workers
    ncubes = 100
    dim = 100def work(none=None):
    return create_cube_np(dim)with ThreadPool(processes=proc) as pool:
    cubes = pool.imap_unordered(work, (None for i in range(ncubes)))
    for n in range(ncubes):
    c = next(cubes) # Cube is retrieved here

    The ThreadPool package is imported here (instead of the usual Pool package) because we want to ensure the following:

    ThreadPool软件包(而不是通常的Pool软件包)被导入此处,因为我们要确保以下几点

    • Stay inside the same process,

      保持相同的过程,
    • Avoid transfer data between processes,

      避免在流程之间传输数据,
    • Getting around the Python Global Interpreter Lock (GIL) by using numpy-only operations (most of numpy calculations are unaffected by the GIL).

      使用仅numpy的操作来解决Python全局解释器锁(GIL)(大多数numpy计算不受GIL的影响)。

    You can learn more about the difference between multiprocessing and multithreading in Python in this nice blog post [7].

    您可以在这篇不错的博客文章[7]中了解有关Python中多处理和多线程之间的区别的更多信息。

    Using this multithreading approach, we only need 0.28s to create one batch of 100 cubes. We reach a very good rate of 355.50 cubes/s, hence a 2370x speedup compared to the very first version (Table 3). Regarding our 1,000,000 cubes, the generation time has dropped under an hour.

    使用这种多线程方法,我们只需要0.28s即可创建一批100个多维数据集。 我们达到了355.50立方/秒的非常高的速率,因此与第一个版本(表3 )相比,提速了2370倍。 对于我们的1,000,000个立方体,生成时间已减少了不到一个小时

    Image for post
    Table 3: Local generation of cubes, speed results.
    表3:本地生成多维数据集,速度结果。

    Now, it’s time to fly by using virtual machine instances in the Cloud!

    现在,是时候通过在中使用虚拟机实例

    提高速度-步骤4:云端 (Improving Speed — Step 4: The Cloud)

    Image for post
    Photo by SpaceX on Unsplash
    SpaceXUnsplash拍摄

    If we talk about Machine Learning as a Service (MLaaS), the top 4 cloud solutions are: Microsoft Azure, Amazon AWS, IBM Watson and Google Cloud Platform (GCP). In this study, we chose GCP but any other provider would do the job. You can select or customize your own configuration among a lot of different virtual machine instances, where you will be able to execute your code inside a Notebook.

    如果我们谈论机器学习即服务( MLaaS ),则排名前四的云解决方案是:Microsoft Azure,Amazon AWS,IBM Watson和Google Cloud Platform(GCP)。 在本研究中,我们选择了GCP,但其他任何提供者都可以胜任。 您可以在许多不同的虚拟机实例中选择或定制自己的配置,从而可以在Notebook中执行代码。

    The first question you want to ask yourself is the following one:

    您要问自己的第一个问题是以下问题:

    “What kind of instance do I want to create that matches my computation needs ?”

    “我想创建什么样的实例来满足我的计算需求?”

    Basically, you can find three types of machines: general purpose, memory-optimized or compute-optimized (Table 4).

    基本上,您可以找到三种类型的计算机:通用计算机,内存优化计算机或计算优化计算机(表4 )。

    Image for post
    Table 4: Machine type recommendations for different workloads.
    表4:针对不同工作负载的机器类型建议。

    To compute the numpy.ndarray from Step 2, parquet files are first stored into a bucket in the Cloud. Then, several tests are conducted on different VM instances (Table 5), keeping the same multithreading code as in Step 3, and progressively increasing the number of vCPUs (workers). An example of results for one virtual machine is presented in Table 6.

    计算numpy步骤2中的ndarray ,首先将实木复合地板文件存储到Cloud中的存储桶中。 然后,在不同的VM实例上进行了几次测试(表5 ),保持与步骤3中相同的多线程代码,并逐渐增加vCPU(工作人员)的数量。 表6中显示了一个虚拟机的结果示例。

    Image for post
    Table 5: Selection of some virtual machine instances.
    表5:一些虚拟机实例的选择。
    Image for post
    n2-highcpu-80" instance. n2-highcpu-80”实例的速度结果。

    In a terminal connected to your virtual machine, you can also visualize the activity of your vCPUs, using the htop linux command (Figure 1).

    在连接到虚拟机的终端中,您还可以使用htop linux命令可视化vCPU的活动(图1 )。

    Image for post
    Figure 1: A look to our army of 160 cores working together (“m1-ultramem-160” instance).
    图1:我们的160个核一起工作的军队的外观(“ m1-ultramem-160”实例)。

    结论 (Conclusion)

    Image for post
    Figure 2: Performance of all the tested VM instances.
    图2:所有经过测试的VM实例的性能。

    Looking at Figure 2, except for the m1-ultramem-160 instance (which is the most expensive), all the other instances perform pretty well, but follow the same pattern. The rate is increasing almost linearly with the number of workers and reaches a peak at 60 vCPUs. Beyond that limit, the rate drops drastically, most probably because of the overhead of the multithreading.

    图2可以看出,除了m1-ultramem-160实例(这是最昂贵的)之外,所有其他实例的性能都很好,但是遵循相同的模式。 该速率几乎随着工人数量呈线性增长,并在60个vCPU处达到峰值。 超过该限制,速率急剧下降,最有可能是由于多线程的开销

    Among our selection, the winner is the n2-highcpu-80 instance (the second cheapest), reaching a rate of 2026.62 cubes/s, almost 2 billion data points per second. At this pace, we can generate 1,000,000 cubes in only 8 minutes.

    在我们的选择中,获胜者n2-highcpu-80实例(第二便宜的实例),达到2026.62立方/秒的速度,每秒20亿个数据点。 以这种速度,我们仅用8分钟就可以生成1,000,000个多维数据集。

    Our initial objective was successfully achieved !

    我们的最初目标已成功实现!

    This whole experiment demonstrates that not only code matters but hardware too. We began with a rate of 0.15 cubes/s on our local machine to reach a very quick rate of 2027 cubes/s, using the Cloud. This is more than a 13,500x speedup !

    整个实验表明,不仅代码很重要,硬件也很重要。 我们使用Cloud在本地计算机上以0.15立方/秒的速率开始,很快达到2027立方/秒的速率。 这不仅仅是13,500倍的加速

    And this is just the beginning… We can level up by using more advanced technologies and infrastructures. This would be for Episode 2.

    而这仅仅是个开始......我们可以用更先进的技术和基础设施升级。 这将是第2集

    翻译自: https://towardsdatascience.com/speed-cubing-for-machine-learning-a5c6775fff0b

    机器人学机器学习与控制

    展开全文
  • numpy机器学习NumPy library is an important foundational tool for studying Machine Learning. Many of its functions are very useful for performing any mathematical or scientific calculation. As it is ...

    numpy机器学习

    NumPy library is an important foundational tool for studying Machine Learning. Many of its functions are very useful for performing any mathematical or scientific calculation. As it is known that mathematics is the foundation of machine learning, most of the mathematical tasks can be performed using NumPy.

    NumPy库是学习机器学习的重要基础工具。 它的许多功能对于执行任何数学或科学计算都非常有用。 众所周知,数学是机器学习的基础,大多数数学任务都可以使用NumPy执行。

    Image for post
    Foundation of Machine Learning
    机器学习基础

    In this story, I will cover the basic concepts of functions in Numpy which are often used.

    在这个故事中,我将介绍Numpy中经常使用的函数的基本概念。

    1.Introduction to NumPyNumPy stands for ‘Numerical Python’. It is an open-source Python library used to perform various mathematical and scientific tasks. It contains multi-dimensional arrays and matrices, along with many high-level mathematical functions that operate on these arrays and matrices.

    1. NumPy简介 NumPy代表“ Numerical Python”。 它是一个开放源代码的Python库,用于执行各种数学和科学任务。 它包含多维数组和矩阵,以及在这些数组和矩阵上运行的许多高级数学函数。

    2. Installing NumPyyou can install NumPy with:conda install numpyorpip install numpy

    2.安装NumPy可以通过以下方式安装NumPy: conda install numpypip install numpy

    3. How to import NumPy?After installing NumPy, you can now use this library by importing it. To import NumPy use:

    3.如何导入NumPy? 安装NumPy之后,您现在可以通过导入使用此库。 要导入NumPy,请使用:

    import numpy as np

    import numpy as np

    4. What is an array?

    4.什么是数组?

    An array is a data structure consisting of a collection of elements (values or variables), each identified by at least one array index or key.

    数组是一种数据结构,由一组元素(值或变量)组成,每个元素均由至少一个数组索引或键标识。

    Image for post

    An array is known as the central data structure of the NumPy library. Array in NumPy is called as NumPy Array.

    数组被称为NumPy库的中央数据结构。 NumPy中的数组称为NumPy数组。

    Image for post

    5. What is the difference between Python List and a Numpy Array?

    5. Python List和Numpy Array有什么区别?

    • Python list can contain elements with different data types whereas Numpy Array‘s elements are always homogeneous(same data types).

      Python列表可以包含具有不同数据类型的元素,而Numpy Array的元素始终是同质的(相同的数据类型)。
    • NumPy arrays are faster and more compact than Python lists.

      NumPy数组比Python列表更快,更紧凑。

    Why NumPy Arrays are faster than Lists?

    为什么NumPy数组比列表快?

    • NumPy Array uses fixed memory to store data and less memory than Python lists.

      NumPy Array使用固定内存来存储数据,并且内存少于Python列表。
    • Contiguous memory allocation in NumPy Arrays.

      NumPy数组中的连续内存分配。

    6. Creating ArraysNumPy Arrays of different dimensions can be created by using ndarray(n-dimensional array). It is an array class in NumPy.The basic ndarray can be created using the numpy.array() function in NumPy.

    6.创建数组 NumPy可以使用ndarray(n-维数组)创建不同维的数组 它是NumPy中的一个数组类。可以使用NumPy中的numpy.array()函数创建基本的ndarray。

    numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

    numpy.array(object,dtype = None,copy = True,order = None,subok = False,ndmin = 0)

    a)1-Dimensional Array

    a)一维数组

    import numpy as np#creating 1-dimensional arrays#creating python list
    list_1 = [3,2,7]
    arr_1 = np.array(list_1,dtype=np.int16)
    print(arr_1)#or
    arr_1=np.array([3,2,7])
    print(arr_1)output:
    [3 2 7]#creating array of complex numberarr_complex = np.array([1, 2, 3], dtype = complex)
    print(arr_complex)output:
    [1.+0.j 2.+0.j 3.+0.j]

    b)Multi-Dimensional array

    b)多维数组

    #creating two-dimensionsal array
    list_m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] #nested lists
    arr_m = np.array(list_m,dtype=np.int16)
    print(arr_m)
    output:
    [[1 2 3]
    [4 5 6]
    [7 8 9]]
    Image for post

    you can create arrays with different Data Types (dtypes): Boolean : np.bool_Char : np.byteShort : np.shortInteger : np.short Long : np.int_ Float : np.single&np.float32 Double :np.double&np.float64 np.int8: integer (-128 to 127)np.int16:integer( -32768 to 32767)np.int32: integer(-2147483648 to 2147483647)np.int64 :integer( -9223372036854775808 to 9223372036854775807)

    您可以创建具有不同数据类型(dtypes)的数组: 布尔值: np.bool_字符: np.byte短: np.short整数: np.short长: np.int_浮点数: np.singlenp.float32 Double: np.doublenp.float64 np.int8 :整数(- 128至127) np.int16 :整数(-32768至32767) np.int32 :整数(-2147483648至2147483647) np.int64 :整数(-9223372036854775808至9223372036854775807)

    c)ndarray in NumPy also provides many functions to create different types of arrays.i)An Array having all elements 0

    c)NumPy中的ndarray 还提供了创建不同类型数组的许多功能。i)具有所有元素的数组0

    #Creating an array of all zeros
    arr_0 = np.zeros((2,2))
    print(arr_0)output:
    [[0. 0.]
    [0. 0.]]

    ii)An Array having all elements 1

    ii)具有所有元素1的数组

    # Creating an array of all ones
    arr_1= np.ones((1,2))
    print(arr_1)output:
    [[1. 1.]]

    iii)An array with a constant

    iii)具有常数的数组

    # Creating a constant array
    arr_c = np.full((2,2), 7)
    print(arr_c)output:
    [[7 7]
    [7 7]]

    iv)Creating an array with start value, end value and number of values

    iv)创建一个包含开始值,结束值和值数的数组

    arr_L = np.linspace(0, 5,7)
    print(arr_L)
    output:
    [0. 0.83333333 1.66666667 2.5 3.33333333 4.16666667
    5. ]#observe here dtype('float64')

    v) Creating an array with start value, end value and number of values(datatypes int)

    v)创建一个包含开始值,结束值和值个数的数组(数据类型为int)

    arr_a=np.arange(1, 10,1)
    print(arr_a)output:
    [1 2 3 4 5 6 7 8 9]#here dtype('int32')

    vi)An array filled with random values

    vi)充满随机值的数组

    arr_r = np.random.random((2,2))  
    print(arr_r)output:
    [[0.05736758 0.58044299]
    [0.57759937 0.85564153]]

    vii)An array filled with random integers

    vii)充满随机整数的数组

    arr_1= np.random.randint(10,100,7)  
    print(arr_1)
    output:
    [43 15 15 62 31 88 69]

    vii) An array filled with random values(which follows Normal Distribution)

    vii)充满随机值的数组(遵循正态分布)

    arr_n= np.random.randn(10)  
    print(arr_n)
    output:
    [ 0.71586489 -0.2929509 0.1952457 1.07499362 0.08089464 -0.18440427
    -0.00194278 0.2594934 1.8713812 -0.76195258]

    viii)Creating a 2x2 identity matrix

    viii)创建2x2身份矩阵

    arr_I = np.eye(2)         Create a 2x2 identity matrix
    print(arr_I)output:
    [[1. 0.]
    [0. 1.]]

    ix)Creating Arrays from existing dataThis is useful for converting Python sequence into ndarray.

    ix)根据现有数据创建数组,这对于将Python序列转换为ndarray非常有用。

    numpy.asarray(a, dtype=None ,order = None)

    numpy.asarray(a,dtype = None,order = None)

    #converting list to ndarray 
    import numpy as npx = [1,2,3]
    a = np.asarray(x)
    print (a)
    output:
    [1 2 3]# ndarray from tuple
    x_1 = (1,2,3)
    a_1 = np.asarray(x_1)
    print (a_1)
    output:
    [1 2 3]# ndarray from list of tuples
    import numpy as npx_2 = [(1,2,3),(4,5)]
    a_2 = np.asarray(x_2)
    print (a_2)
    output:
    [(1, 2, 3) (4, 5)]

    7.Important Arrays attributes

    7,重要的数组属性

    arr.shape :It returns a tuple listing the length of the array along each dimension.

    arr.shape :它返回一个元组,列出沿每个维度的数组长度。

    import numpy as np 
    arr = np.array([[1,2,3],[4,5,6]])
    print (arr.shape)
    output:
    (2, 3)#resizing the above arraya = np.array([[1,2,3],[4,5,6]])
    a.shape = (3,2)
    print (a)
    output:
    [[1 2]
    [3 4]
    [5 6]]or
    a = np.array([[1,2,3],[4,5,6]])
    b = a.reshape(3,2)
    print (b)
    Output:
    [[1, 2]
    [3, 4]
    [5, 6]]
    Image for post

    arr.size :It returns the total number of elements in an array.

    arr.size :它返回数组中元素的总数。

    import numpy as np 
    x = np.array([[3,2,1],[4,6,1]]) print(x.size)
    output:6

    arr.itemsize:It returns the number of bytes per element.

    arr.itemsize:返回每个元素的字节数。

    import numpy as np 
    a = np.array([[1,2,3],[4,5,6]]) a.itemsizeoutput:
    4

    arr.ndim:This array attribute returns the number of array dimensions.

    arr.ndim:此数组属性返回数组维数。

    import numpy as np 
    a = np.array([[1,2,3],[4,5,6]]) a.ndimoutput:
    2

    type(arr) This attribute is used to check the type.

    type(arr)此属性用于检查类型。

    #for example -
    import numpy as np
    arr = np.array([[1,2,3],[4,5,6]])
    print (arr)
    output:
    [[1,2,3]
    [4,5,6]]type(arr)
    output:numpy.ndarray

    arr.dtype:It is used to check the data type or numeric type of the arrays.

    arr.dtype:用于检查数组的数据类型或数字类型。

    #for example -print(arr.dtype)
    output:int32

    arr.nbytes:It returns the number of bytes used by the data portion of the array.

    arr.nbytes:它返回数组的数据部分使用的字节数。

    import numpy as np 
    a = np.array([[1,2,3],[4,5,6]]) a.nbytesoutput:24

    8.Indexing&SlicingIndexing is used to assign numbers to each element in the NumPy array or we can say it maps to the elements stored in an array. It helps to access an array element by referring to its index number.

    8.Indexing&Slicing索引用于为NumPy数组中的每个元素分配数字,或者可以说它映射到存储在数组中的元素。 它通过引用其索引号来帮助访问数组元素。

    Image for post
    Example of Indexing
    索引范例
    import numpy as np
    arr = np.arange(10)
    print(arr)
    output:
    [0 1 2 3 4 5 6 7 8 9]#Example-1print(arr[7])
    or
    print(arr[-3])

    output:
    7#Example-2print(arr[0:5])
    or
    print(arr[0:-4])
    output:[0 1 2 3 4 5]#Example-3print(arr[-4:-1])output:[6 7 8]

    Slicing is an operation used to extract a portion of elements from arrays by specifying lower and upper bound.

    切片是用于通过指定下限和上限从数组中提取元素的一部分的操作。

    arr[lower:upper:step]The lower bound element is included but the upper bound element is not included. The step value indicates the stride between the elements.

    arr [lower:upper:step]包含下限元素,但不包含上限元素。 步长值指示元素之间的步幅。

    Image for post
    Example of Slicing in NumPy Array
    在NumPy数组中切片的示例
    • Slicing 1-Dimensional Array

      切片一维数组
    import numpy as np 
    arr = np.arange(10)#Slicing single elementslice_arr = arr[2]
    print (slice_arr)
    output:[2]#Slicing elements in between indexesprint (arr[2:5])orprint (arr[-8:-5]) #using negative indexoutput:[2,3,4]#using slice(lower,upper,step) functions = slice(2,7,2) print (arr[s])
    output:[2,4,6]orslice_arr = arr[2:7:2]
    print (slice_arr)

    output:[2,4,6]
    • For slicing specific elements

      用于切片特定元素
    x= np.array([11,12,13,14,15])
    print(np.take(x, [0, 3,4]))
    output:
    [11 14 15]
    • Omitting Indices-Omitted boundaries are assumed to be the beginning or end of the array/list. To understand better you can refer the above figure.

      省略索引省略的边界被假定为数组/列表的开始或结尾。 为了更好地理解,您可以参考上图。
    arr=np.arange(10)#Example-1print(arr[:5])
    output:
    [0 1 2 3 4]#Example-2print(arr[5:])
    output:
    [5 6 7 8 9]#Example-3
    print(arr[::2])
    output:
    [0 2 4 6 8]
    • Slicing Multi-Dimensional Arrays

      切片多维数组

      Slicing can be done in multi-dimensional arrays same as the above examples.

      切片可以与上述示例相同的多维数组进行。

    import numpy as np 
    arr = np.array([[1,2,3],[3,4,5],[4,5,6]])
    print (arr)
    output:
    [[1 2 3]
    [3 4 5]
    [4 5 6]]#Slicing first row
    print (arr[0:1])
    output:
    [[1 2 3]]#slicing last 2 rows
    print (arr[1:])
    output:
    [[3 4 5]
    [4 5 6]]#slicing three rows and first column
    print (arr[0:3,0:1])
    output:
    [[1]
    [3]
    [4]]#slicing 4 from above array
    print (arr[1:2,1:2])
    output:
    [[4]]
    Image for post
    Slicing NumPy Arrays
    切片NumPy数组

    9.Stacking & SplittingStacking is used to join a sequence of same dimension arrays along a new axis.numpy.stack(arrays,axis) : It returns a stacked array of the input arrays which has one more dimension than the input arrays.

    9.堆叠和拆分堆叠用于沿着新轴连接一系列相同尺寸的数组。 numpy.stack(arrays,axis) :它返回输入数组的堆叠数组,该数组的维数比输入数组大。

    import numpy as np
    arr_1 = np.array([1, 2, 3])
    arr_2 = np.array([2, 3, 4])arr_stack=np.stack((arr_1,arr_2),axis=0)
    print(arr_stack)
    print(arr_stack.shape)
    output:
    [[1 2 3]
    [2 3 4]](2,3)arr_stack=np.stack((arr_1,arr_2),axis=1)
    print(arr_stack)
    print(arr_stack.shape)
    output:
    [[1 2]
    [2 3]
    [3 4]](3,2)

    The axis parameter specifies the index of the new axis in the dimensions of the result.

    axis参数指定结果尺寸中新轴的索引。

    Image for post
    Stacking in NumPy Arrays
    堆叠在NumPy数组中

    numpy.vstack(tup) : Join arrays in sequence vertically (row-wise). The array formed by stacking will be at least 2-D. The arrays to be stacked must have the same shape along all but the first axis. 1-D arrays must have the same length.

    numpy.vstack(tup) :按顺序垂直(行numpy.vstack(tup)连接数组。 通过堆叠形成的阵列将至少是二维的。 除了第一个轴外,要堆叠的阵列必须具有相同的形状。 一维数组必须具有相同的长度。

    numpy.hstack(tup) : Join arrays in sequence horizontally(column-wise). The arrays to be stacked must have the same shape along all but the second axis, except 1-D arrays which can be any length.

    numpy.hstack(tup) :水平(按列)按顺序连接数组。 除第二个轴外,要堆叠的阵列必须具有相同的形状,一维阵列可以是任意长度。

    # Generate random arrays
    arr_1 = np.random.randint(10, size=(2, 2))
    print(" arr_1\n", arr_1)arr_2 = np.random.randint(10, size=(2, 2))
    print(" arr_2\n", arr_2)output:
    arr_1
    [[0 2]
    [7 6]]
    arr_2
    [[3 7]
    [1 4]]# Stack arr_2 under arr_1
    a=np.vstack((arr_1, arr_2))
    print(a)
    output:
    [[0 2]
    [7 6]
    [3 7]
    [1 4]]# Stacking horizontally
    b=np.hstack((arr_1, arr_2))
    print(b)
    output:
    [[0 2 3 7]
    [7 6 1 4]]
    Image for post
    hstack() & vstack()
    hstack()和vstack()

    numpy.dstack(tup) : Join arrays in sequence depth wise (along the third axis). The array formed by stacking will be at least 3-D. The arrays to be stacked must have the same shape along all but the third axis. 1-D or 2-D arrays must have the same shape.

    numpy.dstack(tup) :按深度顺序(沿第三个轴)连接数组。 通过堆叠形成的阵列将至少是3-D。 除第三条轴外,要堆叠的阵列必须具有相同的形状。 一维或二维阵列必须具有相同的形状。

    #continuing above commands#stacking depth wise
    c=np.dstack((arr_1, arr_2))
    print(c)
    output:[[[0 3]
    [2 7]][[7 1]
    [6 4]]]

    numpy.column_stack(tup) : It works the same as hstack and joins arrays in sequence horizontally(column-wise).

    numpy.column_stack(tup) :它与hstack相同,并按水平顺序(列方式)连接数组。

    numpy.row_stack(tup) : It works the same as vstack and joins arrays in sequence vertically(row-wise).

    numpy.row_stack(tup) :它与vstack相同,并按垂直(行)顺序连接数组。

    # row_stack()
    a=np.row_stack((arr_1, arr_2))
    print(a)
    output:
    [[0 2]
    [7 6]
    [3 7]
    [1 4]]# column_stack()
    b=np.column_stack((arr_1, arr_2))
    print(b)
    output:
    [[0 2 3 7]
    [7 6 1 4]]

    Splitting is used to split an array into multiple sub-arrays. It can be done using following NumPy functions.

    拆分用于将一个数组拆分为多个子数组。 可以使用以下NumPy函数来完成。

    numpy.split(array,Indices_or_sections,axis) : This function used to split an array into multiple sub-arrays of equal size. It returns a list of sub-arrays.

    numpy.split(array,Indices_or_sections,axis) :此函数用于将数组拆分为大小相等的多个子数组。 它返回一个子数组列表。

    x = np.arange(9.0)
    np.split(x, 3)output:
    [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])]

    numpy.array_split(array,Indices_or_sections,axis) : This function is also used to split an array into multiple sub-arrays of equal or near-equal size.

    numpy.array_split(array,Indices_or_sections,axis) :此函数还用于将数组拆分为大小相等或近似相等的多个子数组。

    x = np.arange(8.0)
    np.array_split(x, 3)output:[array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])]x = np.arange(7.0)
    np.array_split(x, 3)output:
    [array([0., 1., 2.]), array([3., 4.]), array([5., 6.])]#all splitted arrays are not equal in size

    numpy.hsplit(array,Indices_or_sections,axis) : This function is also used to split an array into multiple sub-arrays but horizontally (column-wise). hsplit is equivalent to split with axis=1.

    numpy.hsplit(array,Indices_or_sections,axis) :此函数还用于将一个数组拆分为多个子数组,但水平(列方向)。 hsplit等效于使用axis=1.进行split axis=1.

    arr_1 = np.arange(16.0).reshape(4, 4) arr_1
    output:array([[ 0., 1., 2., 3.],
    [ 4., 5., 6., 7.],
    [ 8., 9., 10., 11.],
    [12., 13., 14., 15.]])np.hsplit(arr_1, 2)output:[array([[ 0., 1.],
    [ 4., 5.],
    [ 8., 9.],
    [12., 13.]]),
    array([[ 2., 3.],
    [ 6., 7.],
    [10., 11.],
    [14., 15.]])]np.hsplit(arr_1, np.array([3, 6]))output:[array([[ 0., 1., 2.],
    [ 4., 5., 6.],
    [ 8., 9., 10.],
    [12., 13., 14.]]),
    array([[ 3.],
    [ 7.],
    [11.],
    [15.]]),
    array([], shape=(4, 0), dtype=float64)]

    numpy.vsplit(array,Indices_or_sections,axis) : This function is also used to split an array into multiple sub-arrays but vertically (row-wise). hsplit is equivalent to split with axis=0.

    numpy.vsplit(array,Indices_or_sections,axis) :此函数还用于将一个数组拆分为多个子数组,但垂直(行)。 hsplit等效于使用axis=0.进行split axis=0.

    arr_1= np.arange(16.0).reshape(4, 4)
    arr_1output:
    array([[ 0., 1., 2., 3.],
    [ 4., 5., 6., 7.],
    [ 8., 9., 10., 11.],
    [12., 13., 14., 15.]])np.vsplit(arr_1, 2)
    output:[array([[0., 1., 2., 3.],
    [4., 5., 6., 7.]]), array([[ 8., 9., 10., 11.],
    [12., 13., 14., 15.]])]np.vsplit(arr_1, np.array([3, 6]))output:[array([[ 0., 1., 2., 3.],
    [ 4., 5., 6., 7.],
    [ 8., 9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)]

    11.Basic Maths with NumPy

    第11章NumPy基础数学

    • Addition,Subtraction,Multiplication and Division between two arrays.

      两个数组之间的加法,减法,乘法和除法。
    import numpy as np
    arr_3 = np.array([1, 2, 3, 4])
    arr_4 = np.array([2, 4, 6, 8])# Add values
    print(arr_3 + arr_4)
    ornp.add(arr_3 ,arr_4)
    output:
    [ 3, 6, 9, 12]# Subtract
    print(arr_3 - arr_4)
    ornp.subtract(arr_3 ,arr_4)output:
    [-1, -2, -3, -4]# Multiply
    print(arr_3 * arr_4)or
    np.multiply(arr_3 ,arr_4)
    output:
    [ 2, 8, 18, 32]# Divide
    print(arr_3 / arr_4)ornp.divide(arr_3,arr_4)output:
    [0.5, 0.5, 0.5, 0.5]
    • Operation on array using sum() & cumsum() function.

      使用sum()和cumsum()函数对数组进行操作。
    #Random 2 by 3 digit 2D array between 0 to 100
    arr_6 =np.random.randint(100, size=(2, 3))
    print(arr_6)
    output:
    [[62, 96, 50],
    [87, 26, 42]]# Sum of values in array
    a=arr_3.sum()
    print(a)
    output:
    10# Sum columns
    c=arr_6.sum(axis=0)
    print(c)
    output:
    [149 122 92]# Cumulative sum of rows
    b=arr_6.cumsum(axis=1)
    print(b)
    output:
    [[ 62 158 208]
    [ 87 113 155]]
    • Minimum and Maximum value from an array

      数组的最小值和最大值
    arr=np.array([[62, 96, 50],
    [87, 26, 42]])
    # Min of each row

    print(arr.min(axis=1))
    output:
    [52 1]# Max of each column
    print(arr.max(axis=0))
    output:[87 96 50]
    • Absolute Value of every elements

      每个元素的绝对值
    print(np.absolute([-1, -2]))
    output:
    [1, 2]
    • Exponent/Power , Square Root and Cube Root functions

      指数/幂,平方根和立方根函数
    arr_5 = np.array([[1, 2], [3, 4]])
    arr_6 = np.array([[2, 4], [6, 9]])# Return values in 1st array to powers defined in 2nd arrayprint(np.power(arr_5, arr_6))
    output:
    [[ 1, 16],
    [ 729, 262144]]arr_3 = np.array([1, 2, 3, 4])#Square Root
    print(np.sqrt(arr_3))
    output:
    [1. 1.41421356 1.73205081 2. ]#Cube Root
    print(np.cbrt(arr_3))
    output:[1. 1.25992105 1.44224957 1.58740105]
    • Exponential of all elements in array

      数组中所有元素的指数
    arr_3 = np.array([1, 2, 3, 4])#Exponential of all elements in arrayprint(np.exp(arr_3))
    output:
    [ 2.71828183 7.3890561 20.08553692 54.59815003]
    • Logarithmic Functions

      对数函数
    print(np.log(arr_3))
    output:
    [0. 0.69314718 1.09861229 1.38629436]print(np.log2(arr_3))
    output:
    [0. 1. 1.5849625 2. ]print(np.log10(arr_3))
    output:
    [0. 0.30103 0.47712125 0.60205999]
    • Greatest common divisor

      最大公约数
    print(np.gcd.reduce([9, 12, 15]))
    output:
    3
    • Least Common Multiple

      最小公倍数
    print(np.lcm.reduce([9, 12, 15]))
    output:
    180
    • Round down and Round up of elements of an array

      向下舍入和向上舍入数组的元素
    # Round down
    print(np.floor([1.2, 2.5]))output:
    [1. 2.]# Round up
    print(np.ceil([1.2, 2.5]))
    output:
    [2. 3.]

    12.Trigonometry Functions in NumPy

    12,NumPy中的三角函数

    numpy.sin() :Sine (x) Function

    numpy.sin() :正弦(x)函数

    numpy.cos() :Cosine(x) Function

    numpy.cos() :余弦(x)函数

    numpy.tan() :Tangent(x)Function

    numpy.tan() :Tangent(x)函数

    numpy.sinh() :Hyperbolic Sine (x) Function

    numpy.sinh() :双曲正弦(x)函数

    numpy.cosh() :Hyperbolic Cosine(x) Functionv

    numpy.cosh() :双曲余弦(x)函数numpy.cosh()

    numpy.tanh() :Hyperbolic Tangent(x)Function

    numpy.tanh() :双曲正切(x)函数

    numpy.arcsin() :Inverse Sine Function

    numpy.arcsin() :反正numpy.arcsin()函数

    numpy.arccos() :Inverse Cosine Function

    numpy.arccos() :反余弦函数

    numpy.arctan() : Inverse Tangent Function

    numpy.arctan() :反正切函数

    numpy.pi : pi value

    numpy.pi :pi值

    numpy.hypot(w,h) :For calculating Hypotenuse c = √w² + h²

    numpy.hypot(w,h) :用于计算斜边c =√w²+h²

    numpy.rad2deg() : Radians to degrees

    numpy.rad2deg() :弧度

    numpy.deg2rad() : Degrees to radians

    numpy.deg2rad() :弧度

    • Plotting trigonometric functions

      绘制三角函数
    import numpy as np
    import matplotlib.pyplot as plt# Generate array of 200 values between -pi & pi
    t_arr = np.linspace(-2*np.pi, 2*np.pi, 200)fig = plt.figure()
    ax = plt.axes()
    ax.grid(color='black', linestyle='-', linewidth=2,alpha=0.1)# Plotting Sin(X)
    plt.plot(t_arr, np.sin(t_arr),color='black') # SIN
    plt.title("sin(x)")
    # Display plot
    plt.show()
    Image for post
    #plotting cos(x)
    plt.plot(t_arr, np.cos(t_arr),color='darkorange') # COS
    plt.title("cos(x)")
    Image for post
    #plotting tan(x)
    plt.plot(t_arr, np.tan(t_arr),color='skyblue') # TAN
    plt.title("tan(x)")
    Image for post
    • Plotting all plots in a single graph

      在单个图形中绘制所有图
    plt.plot(t_arr, np.sin(t_arr),color='black',label='sin(x)') # SIN
    plt.plot(t_arr, np.cos(t_arr),color='darkorange',label='cos(x)') # COS
    plt.plot(t_arr, np.tan(t_arr),color='skyblue',label='tan(x)') # TAN
    plt.legend(loc='best')
    plt.show()
    Image for post
    • Inverse trigonometric functions

      反三角函数
    # Provides inverse 
    print(np.arcsin(1))
    print(np.arccos(1))
    print(np.arctan(0))
    output:
    1.5707963267948966
    0.0
    0.0
    • Radians to degrees & Degrees to radians

      弧度到度和度到弧度
    # Radians to degrees
    print(np.rad2deg(np.pi))
    output:
    180.0
    # Degrees to radians
    print(np.deg2rad(180))
    output:
    3.141592653589793

    13.Important Statistics Functions in NumPy

    13,NumPy中重要的统计功能

    numpy.mean() : This function is used to calculate the mean of data.

    numpy.mean() :此函数用于计算数据均值。

    numpy.average() : To calculate the average of any data.

    numpy.average() :计算任何数据的平均值。

    numpy.median() : To calculate the median.

    numpy.median() :计算中位数。

    numpy.mode() : To calculate the mode of any data.

    numpy.mode() :计算任何数据的模式。

    numpy.var() : To calculate the variance of any data.

    numpy.var() :计算任何数据的方差。

    numpy.std() : To calculate the standard deviation.

    numpy.std() :计算标准偏差。

    numpy.percentile() : To calculate percentile values.

    numpy.percentile() :计算百分位值。

    numpy.corrcoef() : To calculate the correlation coefficient.

    numpy.corrcoef() :计算相关系数。

    Examples:

    例子:

    arr_1 = np.arange(1, 6)
    print(arr_1)
    output:
    [1 2 3 4 5]#mean
    print(np.mean(arr_1))
    output:
    3.0#median
    print(np.median(arr_1))
    output:
    3.0#average
    print(np.average(arr_1))
    output:
    3.0# Standard Deviation
    print(np.std([4, 6, 3, 5, 2]))
    output:
    1.4142135623730951#variance
    print(np.var([4, 6, 3, 5, 2]))
    output:
    2.0

    14.Linear Algebra with NumPy

    14,带NumPy的线性代数

    • Vector Transpose

      矢量转置
    import numpy as np
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    v3=[ 4, 6 , 7 ]
    v2= [ 4 ,7 ,9 ]v3t = np.transpose(v3)
    print(v3t)
    output:
    [ 4, 6 , 7 ]
    • Vector Addition & Subtraction

      向量加法和减法
    #taking 2 vectors of same dimention
    v1 = np.array([ 2 ,6 ])
    v2 = np.array([ 5 ,7 ])v3 = v1+v2 #Additionprint(v3)output:
    [ 7, 13]v4 = v2-v1 #Subtraction
    print(v4)
    output:
    [3, 1]
    • Vector Multiplication

      向量乘法
    # VECTOR SCALAR PRODUCT
    v1 = np.array([ 9 ,2 ])
    c= 0.7
    v2= c*v1
    print(v2)
    output:
    [6.3, 1.4]# dot product
    v1 = np.array([ 4 ,3 ,9 ])
    v2 = np.array([ 1 ,2 ,3 ])#method 1
    D_P1 = sum( np.multiply(v1,v2) )
    print(D_P1)
    output:
    37#method 2
    D_P2 = np.dot( v1,v2 )
    print(D_P2)
    output:
    37#method 3
    D_P3= np.matmul( v1,v2 )
    print(D_P3)
    output:
    37
    • Hadamard Multiplication

      哈达玛乘法
    # create vectors
    w1 = [ 1, 3, 5 ]
    w2 = [ 3, 4, 2 ]w3 = np.multiply(w1,w2)
    print(w3)
    output:
    [ 3 12 10]
    • Vector Cross Product

      矢量叉积
    v1 = np.array([3,9,9])
    v2 = np.array([2,3,4])
    v3 = np.cross (v1,v2)
    print (v3)
    output:
    [ 9 6 -9]
    • Vector Length

      向量长度
    #  vector 
    v1 = np.array([ 3,4,6 ])# example method 1
    vl = np.sqrt( sum( np.multiply(v1,v1)) )or# method 2: take the norm
    vl = np.linalg.norm(v1)print(vl)
    output:
    7.810249675906654

    There are many more functions are available in NumPy which can be used to solve problems of linear algebra easily.

    NumPy中提供了更多功能,可轻松解决线性代数问题。

    NumPy is the basis of many other libraries in python, it very vast and difficult to cover full NumPy functions in a single blog. This blog will give you a glance of NumPy library which covers most used functions. So that's the end of this blog.

    NumPy是python中许多其他库的基础,它非常庞大且难以在单个博客中涵盖完整的NumPy函数。 该博客将使您一览NumPy库,其中涵盖了最常用的功能。 到此为止。

    Happy Coding 😊

    快乐编码😊

    翻译自: https://medium.com/mlpoint/numpy-for-machine-learning-211a3e58b574

    numpy机器学习

    展开全文
  • 学习方式 监督式学习: 非监督式学习: 半监督式学习: 强化学习: 算法类似性 回归算法: 基于实例的算法 正则化方法 决策树学习 贝叶斯方法 基于核的算法 聚类算法 关联规则学习 人工神经网络 ...

    目录

    学习方式

    监督式学习:

    非监督式学习:

    半监督式学习:

    强化学习:

    算法类似性

     

    回归算法:

    基于实例的算法

    正则化方法

    决策树学习

    贝叶斯方法

    基于核的算法

    聚类算法

    关联规则学习

    人工神经网络

    深度学习

    降低维度算法

    集成算法:

    决策树

    一、  决策树优点

    二、决策树缺点

    三、改进措施

    三、应用领域

    KNN算法

    一、KNN算法的优点

    二、KNN算法的缺点

    三、KNN算法应用领域

    支持向量机(SVM)

    一、  SVM优点

    二、SVM缺点

    三、SVM应用领域

    AdaBoost算法

    一、  AdaBoost算法优点

    二、Adaboost算法缺点

    三、AdaBoost应用领域

    朴素贝叶斯算法

    一、  朴素贝叶斯算法优点

    二、朴素贝叶斯缺点

    三、朴素贝叶斯应用领域

    Logistic回归算法

    一、logistic回归优点

    二、logistic回归缺点

    三、logistic回归应用领域

    人工神经网络

    一、  神经网络优点

    二、神经网络缺点

    三、人工神经网络应用领域


     机器学习无疑是当前数据分析领域的一个热点内容。很多人在平时的工作中都或多或少会用到机器学习的算法。本文为您总结一下常见的机器学习算法,以供您在工作和学习中参考。

           机器学习的算法很多。很多时候困惑人们都是,很多算法是一类算法,而有些算法又是从其他算法中延伸出来的。这里,我们从两个方面来给大家介绍,第一个方面是学习的方式,第二个方面是算法的类似性。


    学习方式

    根据数据类型的不同,对一个问题的建模有不同的方式。在机器学习或者人工智能领域,人们首先会考虑算法的学习方式。在机器学习领域,有几种主要的学习方式。将算法按照学习方式分类是一个不错的想法,这样可以让人们在建模和算法选择的时候考虑能根据输入数据来选择最合适的算法来获得最好的结果。

    监督式学习:

     

    1479572800-6899-evMLVhLXNyCVuzslOH6trnicCxIA

    在监督式学习下,输入数据被称为“训练数据”,每组训练数据有一个明确的标识或结果,如对防垃圾邮件系统中“垃圾邮件”“非垃圾邮件”,对手写数字识别中的“1“,”2“,”3“,”4“等。在建立预测模型的时候,监督式学习建立一个学习过程,将预测结果与“训练数据”的实际结果进行比较,不断的调整预测模型,直到模型的预测结果达到一个预期的准确率。监督式学习的常见应用场景如分类问题和回归问题。常见算法有逻辑回归(Logistic Regression)和反向传递神经网络(Back Propagation Neural Network)。

    非监督式学习:

    1479572801-7126-ekuYvKanIu4oBcJLm4yvfbDYos0g

    在非监督式学习中,数据并不被特别标识,学习模型是为了推断出数据的一些内在结构。常见的应用场景包括关联规则的学习以及聚类等。常见算法包括Apriori算法以及k-Means算法。

    半监督式学习:

    1479572801-6242-FrMf8f7298cBr0DPW5flDlDMicIw

    在此学习方式下,输入数据部分被标识,部分没有被标识,这种学习模型可以用来进行预测,但是模型首先需要学习数据的内在结构以便合理的组织数据来进行预测。应用场景包括分类和回归,算法包括一些对常用监督式学习算法的延伸,这些算法首先试图对未标识数据进行建模,在此基础上再对标识的数据进行预测。如图论推理算法(Graph Inference)或者拉普拉斯支持向量机(Laplacian SVM.)等。

     

    强化学习:

    1479572801-3762-Y2Xia0H1SegEtIt80ZphH1rueoxg

    在这种学习模式下,输入数据作为对模型的反馈,不像监督模型那样,输入数据仅仅是作为一个检查模型对错的方式,在强化学习下,输入数据直接反馈到模型,模型必须对此立刻作出调整。常见的应用场景包括动态系统以及机器人控制等。常见算法包括Q-Learning以及时间差学习(Temporal difference learning)

     

    在企业数据应用的场景下, 人们最常用的可能就是监督式学习和非监督式学习的模型。 在图像识别等领域,由于存在大量的非标识的数据和少量的可标识数据, 目前半监督式学习是一个很热的话题。 而强化学习更多的应用在机器人控制及其他需要进行系统控制的领域。

     

    算法类似性

    根据算法的功能和形式的类似性,我们可以把算法分类,比如说基于树的算法,基于神经网络的算法等等。当然,机器学习的范围非常庞大,有些算法很难明确归类到某一类。而对于有些分类来说,同一分类的算法可以针对不同类型的问题。这里,我们尽量把常用的算法按照最容易理解的方式进行分类。

    回归算法:

    1479572801-1279-psQzicMbvjWArXBU2JNAOPBODxPA

    回归算法是试图采用对误差的衡量来探索变量之间的关系的一类算法。回归算法是统计机器学习的利器。在机器学习领域,人们说起回归,有时候是指一类问题,有时候是指一类算法,这一点常常会使初学者有所困惑。常见的回归算法包括:最小二乘法(Ordinary Least Square),逻辑回归(Logistic Regression),逐步式回归(Stepwise Regression),多元自适应回归样条(Multivariate Adaptive Regression Splines)以及本地散点平滑估计(Locally Estimated Scatterplot Smoothing)。

    基于实例的算法

    1479572801-1131-ac78ib7ynEpxJzhsOGARzvdvicKA

    基于实例的算法常常用来对决策问题建立模型,这样的模型常常先选取一批样本数据,然后根据某些近似性把新数据与样本数据进行比较。通过这种方式来寻找最佳的匹配。因此,基于实例的算法常常也被称为“赢家通吃”学习或者“基于记忆的学习”。常见的算法包括 k-Nearest Neighbor(KNN), 学习矢量量化(Learning Vector Quantization, LVQ),以及自组织映射算法(Self-Organizing Map , SOM)

    正则化方法

    1479572801-7007-cm573ULFNhgoEA8EJujubjLDb2qA

    正则化方法是其他算法(通常是回归算法)的延伸,根据算法的复杂度对算法进行调整。正则化方法通常对简单模型予以奖励而对复杂算法予以惩罚。常见的算法包括:Ridge Regression, Least Absolute Shrinkage and Selection Operator(LASSO),以及弹性网络(Elastic Net)。

     

    决策树学习

    1479572801-4358-PiaYUw7zqu3954RyeBwhTHkHWk6Q

    决策树算法根据数据的属性采用树状结构建立决策模型, 决策树模型常常用来解决分类和回归问题。常见的算法包括:分类及回归树(Classification And Regression Tree, CART), ID3 (Iterative Dichotomiser 3), C4.5, Chi-squared Automatic Interaction Detection(CHAID), Decision Stump, 随机森林(Random Forest), 多元自适应回归样条(MARS)以及梯度推进机(Gradient Boosting Machine, GBM)

     

    贝叶斯方法

    1479572802-1427-c3vzbPgNXvHoaaNyzGPlN8PBGZFw

    贝叶斯方法算法是基于贝叶斯定理的一类算法,主要用来解决分类和回归问题。常见算法包括:朴素贝叶斯算法,平均单依赖估计(Averaged One-Dependence Estimators, AODE),以及Bayesian Belief Network(BBN)。

    基于核的算法

    1479572802-7140-pibItcdx0RaA35mJGsoZKgBpPmzA

    基于核的算法中最著名的莫过于支持向量机(SVM)了。 基于核的算法把输入数据映射到一个高阶的向量空间, 在这些高阶向量空间里, 有些分类或者回归问题能够更容易的解决。 常见的基于核的算法包括:支持向量机(Support Vector Machine, SVM), 径向基函数(Radial Basis Function ,RBF), 以及线性判别分析(Linear Discriminate Analysis ,LDA)等

    聚类算法

    1479572802-3592-ibHWZ7EllSXgcrDJB9wKJVwbaQ2Q

    聚类,就像回归一样,有时候人们描述的是一类问题,有时候描述的是一类算法。聚类算法通常按照中心点或者分层的方式对输入数据进行归并。所以的聚类算法都试图找到数据的内在结构,以便按照最大的共同点将数据进行归类。常见的聚类算法包括 k-Means算法以及期望最大化算法(Expectation Maximization, EM)。

    关联规则学习

    1479572802-6857-9tm3bibPFEcJ9w2KBxLV7mRn1exQ

    关联规则学习通过寻找最能够解释数据变量之间关系的规则,来找出大量多元数据集中有用的关联规则。常见算法包括 Apriori算法和Eclat算法等。

     

    人工神经网络

    1479572803-5509-3CeY57PHXriauFqH1dVnOmP3P4RA

     

    人工神经网络算法模拟生物神经网络,是一类模式匹配算法。通常用于解决分类和回归问题。人工神经网络是机器学习的一个庞大的分支,有几百种不同的算法。(其中深度学习就是其中的一类算法,我们会单独讨论),重要的人工神经网络算法包括:感知器神经网络(Perceptron Neural Network), 反向传递(Back Propagation), Hopfield网络,自组织映射(Self-Organizing Map, SOM)。学习矢量量化(Learning Vector Quantization, LVQ)

     

    深度学习

    1479572802-5101-zwjPk6sicl7s6PDnQWfsibJZ4SDQ

    深度学习算法是对人工神经网络的发展。 在近期赢得了很多关注, 特别是百度也开始发力深度学习后, 更是在国内引起了很多关注。 在计算能力变得日益廉价的今天,深度学习试图建立大得多也复杂得多的神经网络。很多深度学习的算法是半监督式学习算法,用来处理存在少量未标识数据的大数据集。常见的深度学习算法包括:受限波尔兹曼机(Restricted Boltzmann Machine, RBN), Deep Belief Networks(DBN),卷积网络(Convolutional Network), 堆栈式自动编码器(Stacked Auto-encoders)。

     

    降低维度算法

    1479572803-3312-5jc4UiaQCF66HAQia3icnwxyYK2A

    像聚类算法一样,降低维度算法试图分析数据的内在结构,不过降低维度算法是以非监督学习的方式试图利用较少的信息来归纳或者解释数据。这类算法可以用于高维数据的可视化或者用来简化数据以便监督式学习使用。常见的算法包括:主成份分析(Principle Component Analysis, PCA),偏最小二乘回归(Partial Least Square Regression,PLS), Sammon映射,多维尺度(Multi-Dimensional Scaling, MDS), 投影追踪(Projection Pursuit)等。

     

    集成算法:

    1479572803-6688-tf1SIoQxZaasKHftspLAvvpDWANQ

    集成算法用一些相对较弱的学习模型独立地就同样的样本进行训练,然后把结果整合起来进行整体预测。集成算法的主要难点在于究竟集成哪些独立的较弱的学习模型以及如何把学习结果整合起来。这是一类非常强大的算法,同时也非常流行。常见的算法包括:Boosting, Bootstrapped Aggregation(Bagging), AdaBoost,堆叠泛化(Stacked Generalization, Blending),梯度推进机(Gradient Boosting Machine, GBM),随机森林(Random Forest)。


    决策树

    一、  决策树优点

    1、决策树易于理解和解释,可以可视化分析,容易提取出规则。

    2、可以同时处理标称型和数值型数据。

    3、测试数据集时,运行速度比较快。

    4、决策树可以很好的扩展到大型数据库中,同时它的大小独立于数据库大小。

    二、决策树缺点

    1、对缺失数据处理比较困难。

    2、容易出现过拟合问题。

    3、忽略数据集中属性的相互关联。

    4、ID3算法计算信息增益时结果偏向数值比较多的特征。

    三、改进措施

    1、对决策树进行剪枝。可以采用交叉验证法和加入正则化的方法。

    2、使用基于决策树的combination算法,如bagging算法,randomforest算法,可以解决过拟合的问题

    三、应用领域

    企业管理实践,企业投资决策,由于决策树很好的分析能力,在决策过程应用较多。

     

    KNN算法

    一、KNN算法的优点

     

    1、KNN是一种在线技术,新数据可以直接加入数据集而不必进行重新训练

    2、KNN理论简单,容易实现

    二、KNN算法的缺点

    1、对于样本容量大的数据集计算量比较大。

    2、样本不平衡时,预测偏差比较大。如:某一类的样本比较少,而其它类样本比较多。

    3、KNN每一次分类都会重新进行一次全局运算。

    4、k值大小的选择。

    三、KNN算法应用领域

    文本分类、模式识别、聚类分析,多分类领域

    支持向量机(SVM)

    一、  SVM优点

    1、解决小样本下机器学习问题。

    2、解决非线性问题。

    3、无局部极小值问题。(相对于神经网络等算法)

    4、可以很好的处理高维数据集。

    5、泛化能力比较强。

    二、SVM缺点

    1、对于核函数的高维映射解释力不强,尤其是径向基函数。

    2、对缺失数据敏感。

    三、SVM应用领域

    文本分类、图像识别、主要二分类领域

    AdaBoost算法

    一、  AdaBoost算法优点

    1、很好的利用了弱分类器进行级联。

    2、可以将不同的分类算法作为弱分类器。

    3、AdaBoost具有很高的精度。

    4、相对于bagging算法和Random Forest算法,AdaBoost充分考虑的每个分类器的权重。

    二、Adaboost算法缺点

    1、AdaBoost迭代次数也就是弱分类器数目不太好设定,可以使用交叉验证来进行确定。

    2、数据不平衡导致分类精度下降。

    3、训练比较耗时,每次重新选择当前分类器最好切分点。

    三、AdaBoost应用领域

    模式识别、计算机视觉领域,用于二分类和多分类场景

    朴素贝叶斯算法

    一、  朴素贝叶斯算法优点

    1、对大数量训练和查询时具有较高的速度。即使使用超大规模的训练集,针对每个项目通常也只会有相对较少的特征数,并且对项目的训练和分类也仅仅是特征概率的数学运算而已。

    2、支持增量式运算。即可以实时的对新增的样本进行训练。

    3、朴素贝叶斯对结果解释容易理解。

    二、朴素贝叶斯缺点

    1、由于使用了样本属性独立性的假设,所以如果样本属性有关联时其效果不好。

    三、朴素贝叶斯应用领域

    文本分类、欺诈检测中使用较多

    Logistic回归算法

    一、logistic回归优点

    1、计算代价不高,易于理解和实现

    二、logistic回归缺点

    1、容易产生欠拟合。

    2、分类精度不高。

    三、logistic回归应用领域

    用于二分类领域,可以得出概率值,适用于根据分类概率排名的领域,如搜索排名等。

    Logistic回归的扩展softmax可以应用于多分类领域,如手写字识别等。

    人工神经网络

    一、  神经网络优点

    1、分类准确度高,学习能力极强。

    2、对噪声数据鲁棒性和容错性较强。

    3、有联想能力,能逼近任意非线性关系。

    二、神经网络缺点

    1、神经网络参数较多,权值和阈值。

    2、黑盒过程,不能观察中间结果。

    3、学习过程比较长,有可能陷入局部极小值。

    三、人工神经网络应用领域

    目前深度神经网络已经应用与计算机视觉,自然语言处理,语音识别等领域并取得很好的效果。

    原文:http://suanfazu.com/t/qian-tan-wo-dui-ji-qi-xue-xi-de-dian-li-jie/305

    机器学习方法非常多,也很成熟。下面我挑几个说。

    1. 首先是SVM。因为我做的文本处理比较多,所以比较熟悉SVM。SVM也叫支持向量机,其把数据映射到多维空间中以点的形式存在,然后找到能够分类的最优超平面,最后根据这个平面来分类。SVM能对训练集之外的数据做很好的预测、泛化错误率低、计算开销小、结果易解释,但其对参数调节和核函数的参数过于敏感。个人感觉SVM是二分类的最好的方法,但也仅限于二分类。如果要使用SVM进行多分类,也是在向量空间中实现多次二分类。
      SVM有一个核心函数SMO,也就是序列最小最优化算法。SMO基本是最快的二次规划优化算法,其核心就是找到最优参数α,计算超平面后进行分类。SMO方法可以将大优化问题分解为多个小优化问题求解,大大简化求解过程。某些条件下,把原始的约束问题通过拉格朗日函数转化为无约束问题,如果原始问题求解棘手,在满足KKT的条件下用求解对偶问题来代替求解原始问题,使得问题求解更加容易。 SVM还有一个重要函数是核函数。核函数的主要作用是将数据从低位空间映射到高维空间。详细的内容我就不说了,因为内容实在太多了。总之,核函数可以很好的解决数据的非线性问题,而无需考虑映射过程。

    2. 第二个是KNN。KNN将测试集的数据特征与训练集的数据进行特征比较,然后算法提取样本集中特征最近邻数据的分类标签,即KNN算法采用测量不同特征值之间的距离的方法进行分类。KNN的思路很简单,就是计算测试数据与类别中心的距离。KNN具有精度高、对异常值不敏感、无数据输入假定、简单有效的特点,但其缺点也很明显,计算复杂度太高。要分类一个数据,却要计算所有数据,这在大数据的环境下是很可怕的事情。而且,当类别存在范围重叠时,KNN分类的精度也不太高。所以,KNN比较适合小量数据且精度要求不高的数据。
      KNN有两个影响分类结果较大的函数,一个是数据归一化,一个是距离计算。如果数据不进行归一化,当多个特征的值域差别很大的时候,最终结果就会受到较大影响;第二个是距离计算。这应该算是KNN的核心了。目前用的最多的距离计算公式是欧几里得距离,也就是我们常用的向量距离计算方法。
      个人感觉,KNN最大的作用是可以随时间序列计算,即样本不能一次性获取只能随着时间一个一个得到的时候,KNN能发挥它的价值。至于其他的特点,它能做的,很多方法都能做;其他能做的它却做不了。

    3. 第三个就是Naive Bayes了。Naive Bayes简称NB(牛X),为啥它牛X呢,因为它是基于Bayes概率的一种分类方法。贝叶斯方法可以追溯到几百年前,具有深厚的概率学基础,可信度非常高。Naive Baye中文名叫朴素贝叶斯,为啥叫“朴素”呢?因为其基于一个给定假设:给定目标值时属性之间相互条件独立。比如我说“我喜欢你”,该假设就会假定“我”、“喜欢”、“你”三者之间毫无关联。仔细想想,这几乎是不可能的。马克思告诉我们:事物之间是有联系的。同一个事物的属性之间就更有联系了。所以,单纯的使用NB算法效率并不高,大都是对该方法进行了一定的改进,以便适应数据的需求。
      NB算法在文本分类中用的非常多,因为文本类别主要取决于关键词,基于词频的文本分类正中NB的下怀。但由于前面提到的假设,该方法对中文的分类效果不好,因为中文顾左右而言他的情况太多,但对直来直去的老美的语言,效果良好。至于核心算法嘛,主要思想全在贝叶斯里面了,没啥可说的。

    4. 第四个是回归。回归有很多,Logistic回归啊、岭回归啊什么的,根据不同的需求可以分出很多种。这里我主要说说Logistic回归。为啥呢?因为Logistic回归主要是用来分类的,而非预测。回归就是将一些数据点用一条直线对这些点进行拟合。而Logistic回归是指根据现有数据对分类边界线建立回归公式,以此进行分类。该方法计算代价不高,易于理解和实现,而且大部分时间用于训练,训练完成后分类很快;但它容易欠拟合,分类精度也不高。主要原因就是Logistic主要是线性拟合,但现实中很多事物都不满足线性的。即便有二次拟合、三次拟合等曲线拟合,也只能满足小部分数据,而无法适应绝大多数数据,所以回归方法本身就具有局限性。但为什么还要在这里提出来呢?因为回归方法虽然大多数都不合适,但一旦合适,效果就非常好。
      Logistic回归其实是基于一种曲线的,“线”这种连续的表示方法有一个很大的问题,就是在表示跳变数据时会产生“阶跃”的现象,说白了就是很难表示数据的突然转折。所以用Logistic回归必须使用一个称为“海维塞德阶跃函数”的Sigmoid函数来表示跳变。通过Sigmoid就可以得到分类的结果。
      为了优化Logistic回归参数,需要使用一种“梯度上升法”的优化方法。该方法的核心是,只要沿着函数的梯度方向搜寻,就可以找到函数的最佳参数。但该方法在每次更新回归系数时都需要遍历整个数据集,对于大数据效果还不理想。所以还需要一个“随机梯度上升算法”对其进行改进。该方法一次仅用一个样本点来更新回归系数,所以效率要高得多。

    5. 第五个是决策树。据我了解,决策树是最简单,也是曾经最常用的分类方法了。决策树基于树理论实现数据分类,个人感觉就是数据结构中的B+树。决策树是一个预测模型,他代表的是对象属性与对象值之间的一种映射关系。决策树计算复杂度不高、输出结果易于理解、对中间值缺失不敏感、可以处理不相关特征数据。其比KNN好的是可以了解数据的内在含义。但其缺点是容易产生过度匹配的问题,且构建很耗时。决策树还有一个问题就是,如果不绘制树结构,分类细节很难明白。所以,生成决策树,然后再绘制决策树,最后再分类,才能更好的了解数据的分类过程。
      决策树的核心树的分裂。到底该选择什么来决定树的分叉是决策树构建的基础。最好的方法是利用信息熵实现。熵这个概念很头疼,很容易让人迷糊,简单来说就是信息的复杂程度。信息越多,熵越高。所以决策树的核心是通过计算信息熵划分数据集。

    6. 我还得说一个比较特殊的分类方法:AdaBoost。AdaBoost是boosting算法的代表分类器。boosting基于元算法(集成算法)。即考虑其他方法的结果作为参考意见,也就是对其他算法进行组合的一种方式。说白了,就是在一个数据集上的随机数据使用一个分类训练多次,每次对分类正确的数据赋权值较小,同时增大分类错误的数据的权重,如此反复迭代,直到达到所需的要求。AdaBoost泛化错误率低、易编码、可以应用在大部分分类器上、无参数调整,但对离群点敏感。该方法其实并不是一个独立的方法,而是必须基于元方法进行效率提升。个人认为,所谓的“AdaBoost是最好的分类方法”这句话是错误的,应该是“AdaBoost是比较好的优化方法”才对。

    好了,说了这么多了,我有点晕了,还有一些方法过几天再写。总的来说,机器学习方法是利用现有数据作为经验让机器学习,以便指导以后再次碰到的决策。目前来说,对于大数据分类,还是要借助分布式处理技术和云技术才有可能完成,但一旦训练成功,分类的效率还是很可观的,这就好比人年龄越大看待问题越精准的道理是一样的。这八个月里,从最初的理解到一步步实现;从需求的逻辑推断到实现的方法选择,每天都是辛苦的,但每天也都是紧张刺激的。我每天都在想学了这个以后可以实现什么样的分类,其实想想都是让人兴奋的。当初,我逃避做程序员,主要原因就是我不喜欢做已经知道结果的事情,因为那样的工作没有什么期盼感;而现在,我可以利用数据分析得到我想象不到的事情,这不仅满足了我的好奇感,也让我能在工作中乐在其中。也许,我距离社会的技术需求还有很远的距离,但我对自己充满信心,因为,我不感到枯燥,不感到彷徨,虽然有些力不从心,但态度坚定。

    ===================================================

    http://blog.csdn.NET/vola9527/article/details/43347747

    简述机器学习十大算法的每个算法的核心思想、工作原理、适用情况及优缺点等。

    1)C4.5算法:

    ID3算法是以信息论为基础,以信息熵和信息增益度为衡量标准,从而实现对数据的归纳分类。ID3算法计算每个属性的信息增益,并选取具有最高增益的属性作为给定的测试属性。

    C4.5算法核心思想是ID3算法,是ID3算法的改进,改进方面有:

    1)用信息增益率来选择属性,克服了用信息增益选择属性时偏向选择取值多的属性的不足;

    2)在树构造过程中进行剪枝

    3)能处理非离散的数据

    4)能处理不完整的数据

     C4.5算法优点:产生的分类规则易于理解,准确率较高。

    缺点:

    1)在构造树的过程中,需要对数据集进行多次的顺序扫描和排序,因而导致算法的低效。

    2)C4.5只适合于能够驻留于内存的数据集,当训练集大得无法在内存容纳时程序无法运行。

     

    2)K means 算法:

    是一个简单的聚类算法,把n的对象根据他们的属性分为k个分割,k< n。 算法的核心就是要优化失真函数J,使其收敛到局部最小值但不是全局最小值。

    其中N为样本数,K是簇数,rnk b表示n属于第k个簇,uk 是第k个中心点的值。然后求出最优的uk

     

    优点:算法速度很快

    缺点是,分组的数目k是一个输入参数,不合适的k可能返回较差的结果。

     

    3)朴素贝叶斯算法:

    朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。算法的基础是概率问题,分类原理是通过某对象的先验概率,利用贝叶斯公式计算出其后验概率,即该对象属于某一类的概率,选择具有最大后验概率的类作为该对象所属的类。朴素贝叶斯假设是约束性很强的假设,假设特征条件独立,但朴素贝叶斯算法简单,快速,具有较小的出错率。

    在朴素贝叶斯的应用中,主要研究了电子邮件过滤以及文本分类研究。

     

    4)K最近邻分类算法(KNN)

    分类思想比较简单,从训练样本中找出K个与其最相近的样本,然后看这k个样本中哪个类别的样本多,则待判定的值(或说抽样)就属于这个类别。

    缺点:

    1)K值需要预先设定,而不能自适应

    2)当样本不平衡时,如一个类的样本容量很大,而其他类样本容量很小时,有可能导致当输入一个新样本时,该样本的K个邻居中大容量类的样本占多数。

    该算法适用于对样本容量比较大的类域进行自动分类。

     

    5)EM最大期望算法

    EM算法是基于模型的聚类方法,是在概率模型中寻找参数最大似然估计的算法,其中概率模型依赖于无法观测的隐藏变量。E步估计隐含变量,M步估计其他参数,交替将极值推向最大。

    EM算法比K-means算法计算复杂,收敛也较慢,不适于大规模数据集和高维数据,但比K-means算法计算结果稳定、准确。EM经常用在机器学习和计算机视觉的数据集聚(Data Clustering)领域。

     

    6)PageRank算法

    是google的页面排序算法,是基于从许多优质的网页链接过来的网页,必定还是优质网页的回归关系,来判定所有网页的重要性。(也就是说,一个人有着越多牛X朋友的人,他是牛X的概率就越大。)

    优点:

    完全独立于查询,只依赖于网页链接结构,可以离线计算。

    缺点:

    1)PageRank算法忽略了网页搜索的时效性。

    2)旧网页排序很高,存在时间长,积累了大量的in-links,拥有最新资讯的新网页排名却很低,因为它们几乎没有in-links。

     

    7)AdaBoost

    Adaboost是一种迭代算法,其核心思想是针对同一个训练集训练不同的分类器(弱分类器),然后把这些弱分类器集合起来,构成一个更强的最终分类器(强分类器)。其算法本身是通过改变数据分布来实现的,它根据每次训练集之中每个样本的分类是否正确,以及上次的总体分类的准确率,来确定每个样本的权值。将修改过权值的新数据集送给下层分类器进行训练,最后将每次训练得到的分类器最后融合起来,作为最后的决策分类器。

    整个过程如下所示:
    1. 先通过对N个训练样本的学习得到第一个弱分类器;
    2. 将分错的样本和其他的新数据一起构成一个新的N个的训练样本,通过对这个样本的学习得到第二个弱分类器;
    3. 将和都分错了的样本加上其他的新样本构成另一个新的N个的训练样本,通过对这个样本的学习得到第三个弱分类器;
    4. 如此反复,最终得到经过提升的强分类器。

    目前AdaBoost算法广泛的应用于人脸检测、目标识别等领域。

     

    8)Apriori算法

    Apriori算法是一种挖掘关联规则的算法,用于挖掘其内含的、未知的却又实际存在的数据关系,其核心是基于两阶段频集思想的递推算法 。

    Apriori算法分为两个阶段:

    1)寻找频繁项集

    2)由频繁项集找关联规则

    算法缺点:

    1) 在每一步产生侯选项目集时循环产生的组合过多,没有排除不应该参与组合的元素;

    2) 每次计算项集的支持度时,都对数据库中    的全部记录进行了一遍扫描比较,需要很大的I/O负载。

     

    9)SVM支持向量机

    支持向量机是一种基于分类边界的方法。其基本原理是(以二维数据为例):如果训练数据分布在二维平面上的点,它们按照其分类聚集在不同的区域。基于分类边界的分类算法的目标是,通过训练,找到这些分类之间的边界(直线的――称为线性划分,曲线的――称为非线性划分)。对于多维数据(如N维),可以将它们视为N维空间中的点,而分类边界就是N维空间中的面,称为超面(超面比N维空间少一维)。线性分类器使用超平面类型的边界,非线性分类器使用超曲面。

    支持向量机的原理是将低维空间的点映射到高维空间,使它们成为线性可分,再使用线性划分的原理来判断分类边界。在高维空间中是一种线性划分,而在原有的数据空间中,是一种非线性划分。

    SVM在解决小样本、非线性及高维模式识别问题中表现出许多特有的优势,并能够推广应用到函数拟合等其他机器学习问题中。

     

    10)CART分类与回归树

    是一种决策树分类方法,采用基于最小距离的基尼指数估计函数,用来决定由该子数

    据集生成的决策树的拓展形。如果目标变量是标称的,称为分类树;如果目标变量是连续的,称为回归树。分类树是使用树结构算法将数据分成离散类的方法。

    优点

    1)非常灵活,可以允许有部分错分成本,还可指定先验概率分布,可使用自动的成本复杂性剪枝来得到归纳性更强的树。

    2)在面对诸如存在缺失值、变量数多等问题时CART 显得非常稳健。

    展开全文
  • 机器学习常见算法分类

    千次阅读 2021-02-03 19:32:43
    1 机器学习概念 1.1 机器学习的定义 在维基百科上对机器学习提出以下几种定义: “机器学习是一门人工智能的科学,该领域的主要研究对象是人工智能,特别是如何在经验学习中改善具体算法的性能”。 “机器学习是...

    1 机器学习概念

    1.1 机器学习的定义

    在维基百科上对机器学习提出以下几种定义:

    • “机器学习是一门人工智能的科学,该领域的主要研究对象是人工智能,特别是如何在经验学习中改善具体算法的性能”。
    • “机器学习是对能通过经验自动改进的计算机算法的研究”。
    • “机器学习是用数据或以往的经验,以此优化计算机程序的性能标准。” 一种经常引用的英文定义是:A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E。

    可以看出机器学习强调三个关键词:算法、经验、性能,其处理过程如下图所示。
    这里写图片描述

    上图表明机器学习是数据通过算法构建出模型并对模型进行评估,评估的性能如果达到要求就拿这个模型来测试其他的数据,如果达不到要求就要调整算法来重新建立模型,再次进行评估,如此循环往复,最终获得满意的经验来处理其他的数据。

    1.2 机器学习的分类

    1.2.1 监督学习

    监督是从给定的训练数据集中学习一个函数(模型),当新的数据到来时,可以根据这个函数(模型)预测结果。监督学习的训练集要求包括输入和输出,也可以说是特征和目标。训练集中的目标是由人标注(标量)的。在监督式学习下,输入数据被称为“训练数据”,每组训练数据有一个明确的标识或结果,如对防垃圾邮件系统中“垃圾邮件”、“非垃圾邮件”,对手写数字识别中的“1”、“2”、“3”等。在建立预测模型时,监督式学习建立一个学习过程,将预测结果与“训练数据”的实际结果进行比较,不断调整预测模型,直到模型的预测结果达到一个预期的准确率。常见的监督学习算法包括回归分析和统计分类:

    • 二元分类是机器学习要解决的基本问题,将测试数据分成两个类,如垃圾邮件的判别、房贷是否允许等问题的判断。
    • 多元分类是二元分类的逻辑延伸。例如,在因特网的流分类的情况下,根据问题的分类,网页可以被归类为体育、新闻、技术等,依此类推。
      监督学习常常用于分类,因为目标往往是让计算机去学习我们已经创建好的分类系统。数字识别再一次成为分类学习的常见样本。一般来说,对于那些有用的分类系统和容易判断的分类系统,分类学习都适用。

    监督学习是训练神经网络和决策树的最常见技术。神经网络和决策树技术高度依赖于事先确定的分类系统给出的信息。对于神经网络来说,分类系统用于判断网络的错误,然后调整网络去适应它;对于决策树,分类系统用来判断哪些属性提供了最多的信息,如此一来可以用它解决分类系统的问题。
    这里写图片描述

    1.2.2 无监督学习

    与监督学习相比,无监督学习的训练集没有人为标注的结果。在非监督式学习中,数据并不被特别标识,学习模型是为了推断出数据的一些内在结构。常见的应用场景包括关联规则的学习以及聚类等。常见算法包括Apriori算法和k-Means算法。这类学习类型的目标不是让效用函数最大化,而是找到训练数据中的近似点。聚类常常能发现那些与假设匹配的相当好的直观分类,例如基于人口统计的聚合个体可能会在一个群体中形成一个富有的聚合,以及其他的贫穷的聚合。

    这里写图片描述

    非监督学习看起来非常困难:目标是我们不告诉计算机怎么做,而是让它(计算机)自己去学习怎样做一些事情。非监督学习一般有两种思路:第一种思路是在指导Agent时不为其指定明确的分类,而是在成功时采用某种形式的激励制度。需要注意的是,这类训练通常会置于决策问题的框架里,因为它的目标不是产生一个分类系统,而是做出最大回报的决定。这种思路很好地概括了现实世界,Agent可以对那些正确的行为做出激励,并对其他的行为进行处罚。
    因为无监督学习假定没有事先分类的样本,这在一些情况下会非常强大,例如,我们的分类方法可能并非最佳选择。在这方面一个突出的例子是Backgammon(西洋双陆棋)游戏,有一系列计算机程序(例如neuro-gammon和TD-gammon)通过非监督学习自己一遍又一遍地玩这个游戏,变得比最强的人类棋手还要出色。这些程序发现的一些原则甚至令双陆棋专家都感到惊讶,并且它们比那些使用预分类样本训练的双陆棋程序工作得更出色。

    1.2.3 半监督学习

    半监督学习(Semi-supervised Learning)是介于监督学习与无监督学习之间一种机器学习方式,是模式识别和机器学习领域研究的重点问题。它主要考虑如何利用少量的标注样本和大量的未标注样本进行训练和分类的问题。半监督学习对于减少标注代价,提高学习机器性能具有非常重大的实际意义。主要算法有五类:基于概率的算法;在现有监督算法基础上进行修改的方法;直接依赖于聚类假设的方法等,在此学习方式下,输入数据部分被标识,部分没有被标识,这种学习模型可以用来进行预测,但是模型首先需要学习数据的内在结构以便合理地组织数据来进行预测。应用场景包括分类和回归,算法包括一些对常用监督式学习算法的延伸,这些算法首先试图对未标识数据进行建模,在此基础上再对标识的数据进行预测,如图论推理算法(Graph Inference)或者拉普拉斯支持向量机(Laplacian SVM)等。
    半监督学习分类算法提出的时间比较短,还有许多方面没有更深入的研究。半监督学习从诞生以来,主要用于处理人工合成数据,无噪声干扰的样本数据是当前大部分半监督学习方法使用的数据,而在实际生活中用到的数据却大部分不是无干扰的,通常都比较难以得到纯样本数据。

    这里写图片描述

    1.2.4 强化学习

    强化学习通过观察来学习动作的完成,每个动作都会对环境有所影响,学习对象根据观察到的周围环境的反馈来做出判断。在这种学习模式下,输入数据作为对模型的反馈,不像监督模型那样,输入数据仅仅是作为一个检查模型对错的方式,在强化学习下,输入数据直接反馈到模型,模型必须对此立刻做出调整。常见的应用场景包括动态系统以及机器人控制等。常见算法包括Q-Learning 以及时间差学习(Temporal difference learning)。

    这里写图片描述

    在企业数据应用的场景下,人们最常用的可能就是监督式学习和非监督式学习的模型。在图像识别等领域,由于存在大量的非标识的数据和少量的可标识数据,目前半监督式学习是一个很热的话题。而强化学习更多地应用在机器人控制及其他需要进行系统控制的领域。

    1.3 机器学习的常见算法

    常见的机器学习算法有:

    • 构造条件概率:回归分析和统计分类;
    • 人工神经网络;
    • 决策树;
    • 高斯过程回归;
    • 线性判别分析;
    • 最近邻居法;
    • 感知器;
    • 径向基函数核;
    • 支持向量机;
    • 通过再生模型构造概率密度函数;
    • 最大期望算法;
    • graphical model:包括贝叶斯网和Markov随机场;
    • Generative Topographic Mapping;
    • 近似推断技术;
    • 马尔可夫链蒙特卡罗方法;
    • 变分法;
    • 最优化:大多数以上方法,直接或者间接使用最优化算法。

    根据算法的功能和形式的类似性,我们可以把算法分类,比如说基于树的算法,基于神经网络的算法等等。当然,机器学习的范围非常庞大,有些算法很难明确归类到某一类。而对于有些分类来说,同一分类的算法可以针对不同类型的问题,下面用一些相对比较容易理解的方式来解析一些主要的机器学习算法:

    1.3.1 回归算法

    回归算法是试图采用对误差的衡量来探索变量之间的关系的一类算法。回归算法是统计机器学习的利器。在机器学习领域,人们说起回归,有时候是指一类问题,有时候是指一类算法,这一点常常会使初学者有所困惑。常见的回归算法包括:最小二乘法(Ordinary Least Square),逻辑回归(Logistic Regression),逐步式回归(Stepwise Regression),多元自适应回归样条(Multivariate Adaptive Regression Splines)以及本地散点平滑估计(Locally Estimated Scatterplot Smoothing)。
    这里写图片描述

    1.3.2 基于实例的算法

    基于实例的算法常常用来对决策问题建立模型,这样的模型常常先选取一批样本数据,然后根据某些近似性把新数据与样本数据进行比较。通过这种方式来寻找最佳的匹配。因此,基于实例的算法常常也被称为“赢家通吃”学习或者“基于记忆的学习”。常见的算法包括 k-Nearest Neighbor (KNN),、学习矢量量化(Learning Vector Quantization, LVQ)以及自组织映射算法(Self-Organizing Map,SOM)
    这里写图片描述

    1.3.3 正则化方法

    正则化方法是其他算法(通常是回归算法)的延伸,根据算法的复杂度对算法进行调整。正则化方法通常对简单模型予以奖励而对复杂算法予以惩罚。常见的算法包括:Ridge Regression、Least Absolute Shrinkage and Selection Operator(LASSO)以及弹性网络(Elastic Net)。
    这里写图片描述

    1.3.4 决策树学习

    决策树算法根据数据的属性采用树状结构建立决策模型, 决策树模型常常用来解决分类和回归问题。常见的算法包括:分类及回归树(Classification And Regression Tree, CART)、 ID3 (Iterative Dichotomiser 3)、C4.5、Chi-squared Automatic Interaction Detection (CHAID)、Decision Stump、机森林(Random Forest)、多元自适应回归样条(MARS)以及梯度推进机(Gradient Boosting Machine,GBM)。
    这里写图片描述

    1.3.5 贝叶斯学习

    贝叶斯方法算法是基于贝叶斯定理的一类算法,主要用来解决分类和回归问题。常见算法包括:朴素贝叶斯算法、平均单依赖估计(Averaged One-Dependence Estimators, AODE)以及 Bayesian Belief Network(BBN)。
    这里写图片描述

    1.3.6 基于核的算法

    基于核的算法中最著名的莫过于支持向量机(SVM)了。基于核的算法把输入数据映射到一个高阶的向量空间, 在这些高阶向量空间里, 有些分类或者回归问题能够更容易解决。 常见的基于核的算法包括:支持向量机(Support Vector Machine,SVM)、径向基函数(Radial Basis Function,RBF)以及线性判别分析(Linear Discriminate Analysis,LDA)等。
    这里写图片描述

    1.3.7 聚类算法

    聚类就像回归一样,有时候人们描述的是一类问题,有时候描述的是一类算法。聚类算法通常按照中心点或者分层的方式对输入数据进行归并。所有的聚类算法都试图找到数据的内在结构,以便按照最大的共同点将数据进行归类。常见的聚类算法包括 k-Means 算法以及期望最大化算法(Expectation Maximization,EM)。
    这里写图片描述

    1.3.8 关联规则学习

    关联规则学习通过寻找最能够解释数据变量之间关系的规则,来找出大量多元数据集中有用的关联规则。常见算法包括 Apriori 算法和 Eclat 算法等。
    这里写图片描述

    1.3.9 人工神经网络算法

    人工神经网络算法模拟生物神经网络,是一类模式匹配算法。通常用于解决分类和回归问题。人工神经网络是机器学习的一个庞大的分支,有几百种不同的算法(其中深度学习就是其中的一类算法,我们会单独讨论)。重要的人工神经网络算法包括:感知器神经网络(Perceptron Neural Network)、反向传递(Back Propagation)、Hopfield 网络、自组织映射(Self-Organizing Map, SOM)、学习矢量量化(Learning Vector Quantization,LVQ)。
    这里写图片描述

    1.3.10 深度学习算法

    深度学习算法是对人工神经网络的发展,在近期赢得了很多关注,特别是百度也开始发力深度学习后,更是在国内引起了很多关注。在计算能力变得日益廉价的今天,深度学习试图建立大得多也复杂得多的神经网络。很多深度学习的算法是半监督式学习算法,用来处理存在少量未标识数据的大数据集。常见的深度学习算法包括:受限波尔兹曼机(Restricted Boltzmann Machine, RBN)、 Deep Belief Networks(DBN)、卷积网络(Convolutional Network)、堆栈式自动编码器(Stacked Auto-encoders)。
    这里写图片描述

    1.3.11 降低维度算法

    像聚类算法一样,降低维度算法试图分析数据的内在结构,不过降低维度算法是以非监督学习的方式,试图利用较少的信息来归纳或者解释数据。这类算法可以用于高维数据的可视化或者用来简化数据以便监督式学习使用。常见的算法包括:主成份分析(Principle Component Analysis, PCA)、偏最小二乘回归(Partial Least Square Regression,PLS)、 Sammon 映射、多维尺度(Multi-Dimensional Scaling, MDS)、投影追踪(Projection Pursuit)等。
    这里写图片描述

    1.3.12 集成算法

    集成算法用一些相对较弱的学习模型独立地对同样的样本进行训练,然后把结果整合起来进行整体预测。集成算法的主要难点在于究竟集成哪些独立的较弱的学习模型以及如何把学习结果整合起来。这是一类非常强大的算法,同时也非常流行。常见的算法包括:Boosting、Bootstrapped Aggregation(Bagging)、AdaBoost、堆叠泛化(Stacked Generalization, Blending)、梯度推进机(Gradient Boosting Machine, GBM)、随机森林(Random Forest)。
    这里写图片描述

    参考:https://blog.csdn.net/yirenboy/article/details/47844663 

    https://github.com/Wasabi1234/Spark-MLlib-Tutorial

    https://cloud.tencent.com/developer/article/1411034

    展开全文
  • 我们先带着大家过一遍传统机器学习算法,基本思想和用途。把问题解决思路和方法应用建议提前到这里的想法也很简单,希望能提前给大家一些小建议,对于某些容易出错的地方也先给大家打个预防针,这样在理解后续相应...
  • 机器学习原理详解

    万次阅读 多人点赞 2018-12-22 21:35:42
    对这些数据抽取特征(特征已知,作为判断依据)、标结果(结果已知,作为判断结果),即告诉机器根据什么样的特征可以出什么样的结果,扔给机器学习算法找规律或建模型,找到规律之后可以对其他数据进行根据特征预测...
  • 机器学习的分类与主要算法

    千次阅读 2020-09-21 17:11:58
    机器学习无疑是当前数据分析领域的一个热点内容。很多人在平时的工作中都或多或少会用到机器学习的算法。从范围上来说,机器学习跟模式识别,统计学习,数据挖掘是类似的,同时,机器学习与其他领域的处理技术的结合...
  • 此处梳理出面向人工智能的机器学习方法体系,主要体现机器学习方法和逻辑关系,理清机器学习脉络,后续文章会针对机器学习系列讲解算法原理和实战。抱着一颗严谨学习之心,有不当之处欢迎斧正。     机器学习...
  • 然后是机器学习,出现的稍晚;最后才是深度学习。下面分别介绍一下人工智能、机器学习、深度学习的概述与应用领域: 人工智能: 人工智能是计算机科学的一个分支,它企图了解智能的实质,并生产出一种新的能以...
  • 机器学习算法一览表

    千次阅读 多人点赞 2018-03-31 18:07:33
    尴尬的是,按理说,机器学习介绍与算法一览应该放在最前面写,详细的应用建议应该在讲完机器学习常用算法之后写,突然莫名奇妙在中间插播这么一篇,好像有点打乱主线。  老话说『亡羊补牢,为时未晚』,前面开头忘...
  • counts() df=pd.DataFrame({'获救':Survived_1, '未获救':Survived_0}) df.plot(kind='bar', stacked=True) plt.title("各乘客等级的获救情况") plt.xlabel("乘客等级") plt.ylabel("人数") plt.show() import ...
  • 编辑:图灵人工智能内容来自网络,仅用作知识分享,如有侵权,留言删除根据数据类型的不同,对一个问题的建模有不同的方式。在机器学习或者人工智能领域,人们首先会考虑算法的学习方式。在机器学习领...
  • 机器学习主要类型(二):无监督学习 Unsupervised Learning 2.1 无监督特征学习 Unsupervised Feature Learning 一般用来进行降维、数据可视化或监督学习前期的数据预处理 2.1.1主成分分析 2.1.2稀疏编码 2.1.3自...
  • 机器学习的13种算法和4种学习方法,推荐给大家

    万次阅读 多人点赞 2018-09-18 21:08:45
    机器学习的算法很多。很多时候困惑人们都是,很多算法是一类算法,而有些算法又是从其他算法中延伸出来的。这里,我们从两个方面来给大家介绍,第一个方面是学习的方式,第二个方面是算法的分类。 一、4大主要学习...
  • 机器学习算法集锦

    万次阅读 2017-02-20 22:52:42
    机器学习机器学习(Machine Learning, ML)是一门多领域交叉学科,涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为,以获取新的知识或技能,重新组织已有...
  • 机器学习 技术栈 之 k-近邻算法概述分类按学习方式按功能划分数据集的划分模型拟合程度常见的模型指标模型特征工程参考: 概述 机器学习(Machine Learning,ML) 是一门多领域交叉学科,涉及概率论、统计学、逼近论、凸...
  • 机器学习】无监督学习   https://mp.weixin.qq.com/s/NV84o6Jd_z8evjq05n2jzA     作者:水奈樾 人工智能爱好者 博客专栏:http://www.cnblogs.com/rucwxb/   众所周知,机器学习的训练数据之所以...
  •  机器学习是英文名称Machine Learning(简称ML)的直译。机器学习涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为,以获取新的知识或技能,重新组织已有...
  • 使用机器学习模型预测贷款资格

    千次阅读 2020-09-04 18:04:05
    训练文件将用于训练模型,即我们的模型将从该文件中学习。 它包含所有自变量和目标变量。 Test file contains all the independent variables, but not the target variable. We will apply the model to predict ...
  • tags: [机器学习, ensmeble] Bagging Boosting Stacking&amp;amp;blending 理解 错误认知 正确认知 多维数据的处理办法 方法一 方法二(reshape) Resources: 原始博客查看:小白机器学习博客 ...
  • 机器学习方法分类总结

    千次阅读 2018-09-25 13:53:38
    机器学习方法分类总结 这篇文章只是一个类似于知识概括的文章,主要作用是帮忙梳理: 分类 贝叶斯模型(Bayesian Mode) - 朴素贝叶斯算法(Naive Bayesian Mode) - 平均单依赖估计(AveragedOne-Dependence ...
  • 机器学习概述

    2020-03-30 11:20:41
    文章目录机器学习的分类与主要算法对比1.机器学习方式1.1 监督学习1.2 无监督学习1.3 半监督学习1.4 强化学习2.机器学习常用算法2.1 回归算法(有监督学习)2.2 正则化方法2.3 基于实例的算法2.4 决策树算法2.5 ...
  • 机器学习常用算法: 1)决策树(Decision Tree)  决策树是一种树形结构,为人们提供决策依据,决策树可以用来回答yes和no问题,它通过树形结构将各种情况组合都表示出来,每个分支表示一次选择(选择yes还是no)...
  • 机器学习算法总结

    2019-04-21 22:26:54
    机器学习无疑是当前数据分析领域的一个热点内容。很多人在平时的工作中都或多或少会用到机器学习的算法。本文总结一下常见的机器学习算法,以供参考。机器学习的算法很多,很多算法是一类算法,而有些算法又是从其他...
  • 机器学习——画图方法

    千次阅读 2018-09-12 22:48:50
    , stacked= True ) plt.title( u"按性别看获救情况" ) plt.xlabel( u"性别" ) plt.ylabel( u"人数" ) plt.show() 可以明显看出,女性的获救率远高于男性,可以说是与生存率标签联系非常紧密了。 #上面...
  • 类型转换 # 原始数据表中有数值型和类别型两种数据类型,除了决策树,一般机器学习模型只能读取数值型数据,因此我们需要进行类型的转换 # 我们可以先通过 LabelEncoder 再通过 OneHotEncoder 将str型数据转换成独热...
  • 回归算法是统计学中的主要算法,它已被纳入统计机器学习。 例子: 普通最小二乘回归(Ordinary Least Squares Regression,OLSR) 线性回归(Linear Regression) 逻辑回归(Logistic Regression) 逐步回归...
  • 机器学习的常见分类及常用算法

    千次阅读 2019-06-01 23:54:40
    1. 机器学习的概述 2. 机器学习系统的特点 3.机器学习常见分类 4.机器学习常用算法 1. 机器学习概述 机器学习(Machine Learning, ML)是一门多领域交叉学科,涉及概率论、统计学、逼近论、凸分析、算法...
  • 机器学习算法扫盲篇

    2020-12-30 19:49:28
    总结算法: 从机器学习问题角度分类: 机器学习中有一大部分的问题属于『监督学习』的范畴,简单口语化地说明,这类问题中,给定的训练样本中,每个样本的输入x xx都对应一个确定的结果y yy,我们需要训练出一个模型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,645
精华内容 1,858
关键字:

机器学习stacked