神经网络基础

import numpy as np

# 创建数组
array = np.array([1, 2, 3, 4])  # 一维数组
matrix = np.array([[1, 2], [3, 4]])  # 二维数组

# 数组属性
print(array.shape)  # 查看数组形状
print(array.ndim)   # 查看数组维度
print(array.dtype)  # 查看数据类型

# 常用操作
zeros = np.zeros((2, 3))  # 创建全零数组
ones = np.ones((2, 3))    # 创建全一数组
arange = np.arange(0, 10, 2)  # 创建等差序列
linspace = np.linspace(0, 1, 5)  # 创建线性等分点

# 数学运算
array = np.array([1, 2, 3])
print(array + 10)        # 数组加法（广播机制）
print(array * 2)         # 数组乘法
print(np.mean(array))    # 平均值
print(np.sum(array))     # 求和
print(np.dot(array, array))  # 点积

# 数组索引和切片
print(array[1])  # 索引第2个元素
print(matrix[:, 1])  # 切片：取二维数组每行的第2列

import pandas as pd

# 创建 Series
series = pd.Series([10, 20, 30], index=['a', 'b', 'c'])  # 一维数据
print(series['a'])  # 按索引取值

# 创建 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35], 'Score': [85, 90, 95]}
df = pd.DataFrame(data)  # 二维表格数据
print(df)

# 查看数据
print(df.head())    # 查看前5行
print(df.info())    # 查看数据概要
print(df.describe())  # 查看统计信息

# 数据选择
print(df['Name'])   # 按列选择
print(df.iloc[0])   # 按行索引选择
print(df.loc[0, 'Name'])  # 按行列标签选择

# 数据筛选
print(df[df['Age'] > 25])  # 筛选 Age 大于 25 的行

# 数据处理
df['Age'] = df['Age'] + 1  # 修改列数据
df['New_Column'] = df['Score'] / 10  # 添加新列

# 处理缺失值
df['Score'] = [85, None, 95]
print(df.dropna())  # 删除缺失值行
print(df.fillna(0))  # 用 0 填充缺失值

# 排序
print(df.sort_values(by='Age', ascending=False))  # 按 Age 列降序排列

# 创建 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Score': [85, 90, 95]
}
df = pd.DataFrame(data)
print(df)

# 查看数据
print(df.head())  # 查看前5行
print(df.info())  # 查看数据概要
print(df.describe())  # 查看统计信息

# 修改数据
df['Age'] = df['Age'] + 1  # 修改 Age 列的值
df['New_Column'] = df['Score'] / 10  # 添加新列
print(df)

# 筛选 Age 大于 30 的行
filtered_df = df[df['Age'] > 30]
print(filtered_df)

# 多条件筛选
filtered_df = df[(df['Age'] > 30) & (df['Score'] > 90)]
print(filtered_df)

# 创建包含缺失值的数据
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, None, 35], 'Score': [85, 90, None]}
df = pd.DataFrame(data)

# 检测缺失值
print(df.isnull())  # 返回布尔值矩阵
print(df.isnull().sum())  # 每列缺失值数量

# 删除缺失值
print(df.dropna())  # 删除包含缺失值的行

# 填充缺失值
df_filled = df.fillna(0)  # 用0填充
print(df_filled)

# 按 Age 列降序排序
sorted_df = df.sort_values(by='Age', ascending=False)
print(sorted_df)

import numpy as np

# 定义Sigmoid激活函数及其导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return x * (1 - x)

# 定义神经网络类
class NeuralNetwork:
    def __init__(self, input_size, output_size):
        # 初始化权重和偏置
        self.weights = np.random.rand(input_size, output_size)
        self.bias = np.random.rand(1, output_size)
    
    def feedforward(self, X):
        # 前向传播
        self.z = np.dot(X, self.weights) + self.bias
        self.a = sigmoid(self.z)
        return self.a
    
    def backpropagation(self, X, y, output, learning_rate):
        # 反向传播
        error = y - output
        d_output = error * sigmoid_derivative(output)
        d_weights = np.dot(X.T, d_output)
        d_bias = np.sum(d_output, axis=0, keepdims=True)
        
        # 更新权重和偏置
        self.weights += learning_rate * d_weights
        self.bias += learning_rate * d_bias
    
    def train(self, X, y, epochs, learning_rate):
        for epoch in range(epochs):
            output = self.feedforward(X)
            self.backpropagation(X, y, output, learning_rate)
            if epoch % 1000 == 0:
                loss = np.mean(np.square(y - output))
                print(f"Epoch {epoch}, Loss: {loss}")

# 示例数据
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

# 创建神经网络实例
input_size = 2
output_size = 1
nn = NeuralNetwork(input_size, output_size)

# 训练神经网络
epochs = 10000
learning_rate = 0.1
nn.train(X, y, epochs, learning_rate)

# 测试神经网络
test_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
predictions = nn.feedforward(test_data)
print("Predictions:")
print(predictions)