分类： 神经网络/数学

np.vstack()：在竖直方向上堆叠。

np.hstack()：在水平方向上平铺。

import numpy as np

arr1 = np.array([1,2,3])

arr2 = np.array([4,5,6])

print(np.vstack((arr1,arr2)))

print(‘——————‘)

print(np.hstack((arr1,arr2)))

import numpy as np

arr1 = np

numpy中的ravel函数的作用是让多维数组变成一维数组。

import numpy as np

# 对二维数组进行reval

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

print(“二维数组a:”)

b=a.ravel()

#对a进行拉伸操作

print(“对a进行ravel操作后：”)

print(b)

# 对三维数组进行reval

c = np.array([ [[1, 2, 3], [4, 5, 6]], [[7,

A、B、C、D、E、F是6个网格点，坐标如图，如何用矩阵形式（坐标矩阵）来批量描述这些点的坐标呢？

语法：X,Y = numpy.meshgrid(x, y)

输入的x，y，就是网格点的横纵坐标列向量（非矩阵）。

输出的X，Y，就是坐标矩阵。

import numpy as np

import matplotlib.pyplot as plt

x = np.array([0, 1, 2])

y = np.array([0, 1])

X, Y = np.

#填入一个参数，默认起点0，终点为参数，步长为1。

x = np.arange(10)

print(x)

#填入二个参数，起点为参数a，终点为参数b，步长为1。

y = np.arange(1, 10)

print(y)

#填入三个参数，起点为参数a，终点为参数b，步长为c。

z = np.arange(1, 10, 0.5)

print(z)

// 使用math库里的宏常量

#define _USE_MATH_DEFINES

#include <iostream>

#include <filesystem>

#include <string>

#include <windows.h>

using namespace std;

// 对数 指数

void test_math()

{

// 对数函数

double param, result;

package cn.howsky.app.util;

public class Test {

public static void main(String[] args) {

// 数值的平方根

double x = 4;

double y = Math.sqrt(x);

System.out.println(“4的平方根” + y);

// 将 c 的值设置为 a 的 b 次幂

double a = 3;

double b = 2;

double

double m, n;

m = Math.Exp(0.5); // 自然对数e的0.5次方

Console.WriteLine(“自然对数e的0.5次方：” + m);

n = Math.Exp(30); // 自然对数e的30次方

Console.WriteLine(“自然对数e的30次方：” + n);

n = Math.Log(3); // 以e为底，3的对数

Console.WriteLine(“以e为底，3的对数：” + n);

n = Math.L

已知两条直线 相交，那么如何求这两条直线交点的坐标？

（1）、若方程组有唯一解，则两直线有唯一交点，两直线相交。

（2）、若方程组无解，则两直线无交点，两直线平行。

（3）、若方程组有无数组解，则两直线有无数交点，两直线重合。

numpy提供了numpy.squeeze(a, axis=None)函数，从数组的形状中删除单维条目。

其中a表示输入的数组。axis用于指定需要删除的维度，但是指定的维度必须为单维度，否则将会报错。

axis的取值可为None 或 int 或 tuple of ints，若axis为空时则删除所有单维度的条目。

import numpy as np

a = np.array([[[0], [1], [2]]])

b = np.squeeze(a)

c = np.squ

例子1：

import numpy as np

# np.argmax(a) 返回的是a中元素最大值所对应的索引值

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

print(correct, ‘\n’)

# 行 最大值所对应的索引值

b = np.argmax(correct, axis=1)

print(b)

# 列 最大值所对应的索引值

c = np.argmax(correct,

独热编码即 One-Hot 编码，又称一位有效编码，其方法是使用N位状态寄存器来对N个状态进行编码，每个状态都有它独立的寄存器位，并且在任意时候，其中只有一位有效。

import numpy as np

correct = np.array([0, 1, 2, 3, 4, 5,

6])

n_data = len(correct)

# — 将 周一至周日 转换为独热编码格式 —

correct_data = np.zeros((n_data, 7))

print(c

import numpy as np

cols = np.array([[1, 2, 3, 4],

[5, 6, 7, 8],

[9, 10,11,12],

[13,14,15,16]])

print(cols)

print(“\n”)

# reshape 默认按行填充

# 三维 表示 2个(2,4)

w = cols.reshape(2, 2, 4)

print(w)

print(“\n”)

# 四维 表示 1个(2,2,4)

x =

np.pad(array，pad_width，mode，**kwargs)  # 返回填充后的numpy数组

array：要填充的numpy数组【要对谁进行填充】

pad_width：每个轴要填充的数据的数目【每个维度前、后各要填充多少个数据】

mode：填充的方式【采用哪种方式填充】

import numpy as np

# 一维

a = np.array([1, 2, 3, 4, 5])

print(“a.shape”, a.shape)

b = np.

import numpy as np

#将数组打乱随机排列 两种方法：

#1 np.random.shuffle(x)：在原数组上进行，改变自身序列，无返回值。

x = np.arange(5)

print(x)

np.random.shuffle(x)

print(x)

#2 np.random.permutation(x)：不在原数组上进行，返回新的数组，不改变自身数组。

y = np.arange(5)

print(y)

z = np.random.

import numpy as np

import matplotlib.pyplot as plt

# param:起点，终点，间距

x = np.arange(-10, 10, 0.2)

y = 1/(1 + np.exp(-x))

dy = y * (1 – y)

plt.plot(x, y)

plt.plot(x, dy)

plt.show()

sigmoid函数的求导推导过程

#python 中

幂运算与正负号

#python 中

如果幂运算前有正负号，则 – + 的优先级会比**低。而当 – + 在后面时，优先级会比 ** 高。

import numpy as np

print(-9 ** 0.5)

print(-(9 ** 0.5))

print(9 ** -0.5) #变倒数

print(9 ** 0.5)

print(4 ** -0.5) #变倒数

print(‘a’, np.log(0.001))

print

#1. np.dot(a, b), 其中a为一维的向量，b为一维的向量，当然这里a和b都是np.ndarray类型的, 此时因为是一维的所以是向量点积。

import numpy as np

a = np.array([0, 1, 2])

b = np.array([1, 2, 3])

# 0*1 + 1*2 + 2*3

print(np.dot(a, b))

# 8

#2. np.dot(a, b), 其中a为二维矩阵，b为一维向量，这时b会被当做一维矩阵进行计算。

%matplotlib inline

import numpy as np

import matplotlib.pyplot as plt

# x、y坐标

X = np.arange(-1.0, 1.0, 0.2)

# 元素数量是10个

Y = np.arange(-1.0, 1.0, 0.2)

# 容纳输出的10×10的网格 用0填充

Z = np.zeros((10,10))

# x、y坐标的输入的权重

w_x = 2.5

w_y = 3.0

import numpy as np

r = 2

c = 2

#在默认的情况下，zeros创建的数组元素类型是浮点型的，如果要使用其他类型，可以设置dtype参数进行声明。

X = np.zeros((3,3))

#X = np.zeros((3,3),dtype=int)

X[0, 1:] = 77

X[1:, 0] = 99

print(X)

for i in range(r):

#print(“i=” + str(i))

for j in ran

神经网络中的每个节点接受输入值，并将输入值传递给下一层，输入节点会将输入属性值直接传递给下一层（隐藏层或输出层）。在神经网络中，隐层和输出层节点的输入和输出之间具有函数关系，这个函数称为激励函数（激活函数）。

1、Sigmoid函数

%matplotlib inline

import numpy as np

import matplotlib.pylab as plt

def sigmoid_function(x):

return 1/(1 + np.exp(-x))