python笔记--2023.11-CSDN博客

本文链接：https://blog.csdn.net/weixin_43643881/article/details/134426719

1.torch.squeeze

torch.squeeze函数可以删除张量中维度为1的维度。

import torch

x = torch.tensor([[0], [0], [1], [1]])
y = torch.squeeze(x)

print(y)
#tensor([0, 0, 1, 1])

2.torch.sub

import torch

# 假设 mirna_node_info['mirna_id'].values 是一个包含整数的数组
mirna_ids = torch.tensor(mirna_node_info['mirna_id'].values, dtype=torch.int64)
mirna_ids_minus_one = torch.sub(mirna_ids, 1)

print(mirna_ids_minus_one)
#tensor([0, 1, 2, ...])  # 减去1后的张量

3.dgl block, block[0], block[-1]

在DGL（Deep Graph Library）中，Block是指由多个图层（layers）组成的模块，用于构建图神经网络中的多层结构。每个图层通常包含一个或多个图神经网络模型（如GCN、GAT等），用于在每个层级上进行节点特征的聚合和传递。

Block的使用可以帮助构建更深层次的图神经网络模型，通过多次迭代地在不同层级上进行特征传递和聚合，以获得更丰富的表示能力。Block可以通过多个图层的堆叠来实现，每个图层都可以有不同的参数和操作。

在DGL中，可以通过以下步骤来使用Block：

定义Block的结构：首先，需要定义Block的结构，即确定每个图层的类型和参数。可以选择使用现有的图神经网络模型，如GCN、GAT等，也可以自定义图层结构。
创建Block对象：使用定义好的结构，创建Block对象。可以使用dgl.nn.Block类或其子类来创建Block对象。
前向传播：在训练或推理过程中，通过调用Block对象的forward函数进行前向传播。在每个图层上，将输入的节点特征作为输入，通过图神经网络模型进行特征传递和聚合，得到更新后的节点特征。

block[0]和block[-1]是Block中的索引表示，表示Block中的第一个图层和最后一个图层。

block[0]表示Block中的第一个图层，即索引为0的图层。它通常是输入图层，用于接收原始的节点特征作为输入。
block[-1]表示Block中的最后一个图层，即索引为-1的图层。它通常是输出图层，用于输出最终的节点特征。

通过这些索引，我们可以在Block中访问不同的图层，可以对它们进行个性化的配置和操作，比如修改参数、获取中间层的输出等。

总而言之，Block是DGL中用于构建多层图神经网络模型的模块，它可以通过堆叠多个图层来实现深层网络结构。block[0]和block[-1]分别表示Block中的第一个图层和最后一个图层，用于获取输入和输出的节点特征。

4. 基于网络的方法转移一个训练好的模型来进行新节点的链接预测

import dgl
import torch
import torch.nn as nn

# 步骤1: 基础模型训练
# 假设已经使用已有的节点和边的信息构建了图数据
# 这里使用一个简单的图神经网络模型作为示例
class GraphModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(GraphModel, self).__init__()
        self.gcn = GCN(input_size, hidden_size)
        self.linear = nn.Linear(hidden_size, output_size)
    
    def forward(self, g, features):
        h = self.gcn(g, features)
        logits = self.linear(h)
        return logits

# 假设已经训练好了基础模型
base_model = GraphModel(input_size, hidden_size, output_size)
# ... 在训练数据上训练模型 ...

# 步骤2: 转移学习
# 保存已训练好的基础模型的参数
base_model_path = 'base_model.pth'
torch.save(base_model.state_dict(), base_model_path)

# 步骤3: 新节点特征提取
# 对于新的待预测节点，根据其属性信息提取特征
new_node_features = extract_features(new_node)

# 步骤4: 链接预测
# 加载保存的基础模型参数
base_model = GraphModel(input_size, hidden_size, output_size)
base_model.load_state_dict(torch.load(base_model_path))

# 将新节点特征输入到基础模型中进行预测
prediction = base_model(graph, new_node_features)

# 根据预测值和设定的链接阈值判断链接的存在与否
threshold = 0.5
if prediction > threshold:
    print("Link exists.")
else:
    print("Link does not exist.")

5.CSV文件的最左侧新增一列，并从0开始为该列编号

使用df.insert()方法在最左侧插入一列，列名为Index，并使用range(len(df))为该列编号，即从0开始递增。最后，使用df.to_csv()方法将修改后的DataFrame保存为CSV文件

import pandas as pd

# 读取CSV文件
df = pd.read_csv('your_file.csv')

# 新增一列，并从0开始为该列编号
df.insert(0, 'Index', range(len(df)))

# 保存修改后的CSV文件
df.to_csv('new_file.csv', index=False)

6. 获取csv文件的行数

使用pandas库中的shape属性，它返回一个元组，其中包含DataFrame的行数和列数。

import pandas as pd

# 读取CSV文件
df = pd.read_csv('your_file.csv')

# 获取CSV文件的行数
num_rows = df.shape[0]

print("CSV文件的行数：", num_rows)

7.根据列名读取dataframe文件中的特定列，并组成新的dataframe

import pandas as pd

# 读取原始DataFrame文件
df = pd.read_csv('your_file.csv')

# 选择特定的列
selected_columns = ['col1', 'col2', 'col3']  # 替换为你需要选择的列名
new_df = df[selected_columns].copy()

# 打印新的DataFrame
print(new_df)

8. dataframe根据值筛选

import pandas as pd

# 读取原始DataFrame文件
df = pd.read_csv('your_file.csv')

# 筛选Label为0的行
df_label_0 = df[df['Label'] == 0].copy()

# 筛选Label为1的行
df_label_1 = df[df['Label'] == 1].copy()

# 打印新的DataFrame
print("Label为0的DataFrame:")
print(df_label_0)

print("Label为1的DataFrame:")
print(df_label_1)

9. format与f-string

format()方法和f-string（格式化字符串字面值）是Python中用于字符串格式化的两种常用方法。

format()方法：
- format()方法是一种用于字符串格式化的灵活方法，它可以在字符串中插入变量、值和表达式。
- 使用{}作为占位符来表示要插入的值的位置，并使用format()方法将要插入的值传递给字符串。
- 通过在{}中使用索引或关键字参数，可以控制值的插入位置和格式。
- 示例代码：
```
name = "Alice"
age = 25
message = "My name is {} and I'm {} years old.".format(name, age)
print(message)
```
  输出：
```
My name is Alice and I'm 25 years old.
```
f-string（格式化字符串字面值）：
- f-string是自Python 3.6版本引入的一种字符串格式化方法，它提供了一种简洁、直观的方式来插入变量和表达式到字符串中。
- 使用f-string时，可以在字符串前加上字母f，然后在字符串中使用花括号{}将变量或表达式括起来。
- f-string会自动将花括号内的内容替换为相应的变量值或表达式的结果。
- 示例代码：
```
name = "Alice"
age = 25
message = f"My name is {name} and I'm {age} years old."
print(message)
```
  输出：
```
My name is Alice and I'm 25 years old.
```

两种方法都可以实现字符串的格式化，但f-string在语法上更简洁和易读。它提供了直接在字符串中插入变量和表达式的能力，使得代码更加清晰和易于维护。然而，format()方法在一些更复杂的格式化场景下可能更具灵活性。选择使用哪种方法取决于个人偏好和代码的要求。

10.csv文件，行索引%6=0和行索引%6=1的生成一个新的csv文件

import pandas as pd

# 读取原始CSV文件
df = pd.read_csv('input.csv')

# 筛选行索引模6等于0或1的数据
filtered_df = df[df.index % 6.isin([0, 1])]

# 将筛选后的数据保存为新的CSV文件
filtered_df.to_csv('output.csv', index=False)

11.修改csv的一列，该列数值从1开始递增

import pandas as pd

# 读取CSV文件
df = pd.read_csv('input.csv')

# 修改指定列的数值从1开始递增
df['Column_Name'] = range(1, len(df) + 1)

# 保存修改后的数据为新的CSV文件
df.to_csv('output.csv', index=False)

import pandas as pd

# 读取CSV文件
df = pd.read_csv('input.csv')

# 修改指定列的数值从-1开始递减
df['Column_Name'] = range(-1, -len(df)-1, -1)

# 保存修改后的数据为新的CSV文件
df.to_csv('output.csv', index=False)

12.dataframe对齐

已知一个mirna特征的csv文件，和一个仅包含部分mirna名称的csv文件，从特征文件中获取部分mirna的特征并生成一个新的csv文件。

import pandas as pd

# 读取mirna特征的CSV文件
feature_df = pd.read_csv('feature_file.csv')

# 读取包含部分mirna名称的CSV文件
mirna_names_df = pd.read_csv('mirna_names_file.csv')

# 从特征文件中筛选部分mirna的特征
filtered_df = feature_df[feature_df['mirna'].isin(mirna_names_df['mirna'])]

# 保存筛选后的特征为新的CSV文件
filtered_df.to_csv('filtered_feature_file.csv', index=False)

13.dataframe合并

这段代码使用了pandas的merge()函数将两个DataFrame对象mirna_node和mirna_fea进行合并，并根据’mirna’列和’Seqname’列进行匹配。

mirna_node_info = pd.merge(mirna_node, mirna_fea, left_on='mirna', right_on='Seqname', how='left', sort=False)

mirna_node和mirna_fea是要合并的两个DataFrame对象。
left_on='mirna'表示以’mirna’列作为左侧DataFrame的合并键。
right_on='Seqname'表示以’Seqname’列作为右侧DataFrame的合并键。
how='left'表示采用左连接方式，即保留左侧DataFrame中的所有行。
sort=False表示不对结果进行排序。

合并后的结果存储在mirna_node_info中，包含了mirna_node和mirna_fea两个DataFrame中匹配的行和列。

请注意，合并的结果取决于’mirna’列和’Seqname’列的匹配情况。确保这两列包含相同的值或具有匹配关系，以便正确执行合并操作。

14.删除包含缺失值（NaN）的行

这段代码使用pandas的dropna()函数删除mirna_node_info DataFrame中’subset’指定的列中包含缺失值（NaN）的行。

mirna_node_info = mirna_node_info.dropna(subset=['Seqname'])

mirna_node_info是要操作的DataFrame对象。
dropna()函数用于删除包含缺失值的行。
subset=['Seqname']指定了要检查缺失值的列，这里是’Seqname’列。

经过该操作后，mirna_node_info DataFrame中所有’Seqname’列中包含缺失值的行将被删除。

15.删除重复项

mirna_node = Label_data_pair.drop(columns=['Label', 'pair_id', 'lncrna', 'lncrna_id']).drop_duplicates(subset=['mirna'], keep='first').copy()

这行代码的作用是从DataFrame Label_data_pair 中筛选出包含 mirna 列的唯一值，并创建一个新的DataFrame对象 mirna_node。

drop(columns=['Label', 'pair_id', 'lncrna', 'lncrna_id'])：该部分使用 drop() 方法删除指定列，即 'Label'、'pair_id'、'lncrna' 和 'lncrna_id' 列。
drop_duplicates(subset=['mirna'], keep='first')：该部分使用 drop_duplicates() 方法根据 'mirna' 列的唯一值进行去重操作。参数 subset=['mirna'] 指定以 'mirna' 列为基准进行去重，参数 keep='first' 表示保留第一个出现的重复值。
copy()：该方法用于创建 mirna_node 的副本，以确保生成的新DataFrame与原始DataFrame完全独立。

因此，以上代码根据 'mirna' 列的唯一值筛选出了一个新的DataFrame对象 mirna_node，并且删除了 'Label'、'pair_id'、'lncrna' 和 'lncrna_id' 列。

16. 根据csv文件的列生成字典

键是每个mirna，值是从1开始递增的整数：

import csv

mirna_list = []
mirna_dict = {}

# 读取CSV文件
with open('mirna_file.csv', 'r') as file:
    reader = csv.reader(file)
    next(reader)  # 跳过标题行
    for row in reader:
        mirna = row[0]
        mirna_list.append(mirna)

# 生成字典
for i, mirna in enumerate(mirna_list, start=1):
    mirna_dict[mirna] = i

首先，代码打开CSV文件并使用csv.reader逐行读取文件内容。我们假设文件中的mirna列表位于第一列，因此我们使用 row[0] 获取每行的mirna值，并将其添加到 mirna_list 列表中。

然后，我们使用 enumerate() 函数遍历 mirna_list 列表，并从1开始递增生成键值。每个mirna作为键，对应的递增整数作为值，存储在 mirna_dict 字典中。

最终，mirna_dict 将包含每个mirna作为键，从1开始递增的整数作为值的字典。

17. 根据字典生成修改csv对应的值

已知csv文件的格式为 Unnamed:
0,mirna,lncrna,Label,pair_index,mirna_id,lncrna_id,pair_id
0,ath-miR5020a,CNT2086271,1,0,1,-1,0
1,ath-miR403-5p,CNT2084906,0,1,2,-2,1
6,ath-miR164c-5p,CNT2086832,1,2,3,-3,2
7,ath-miR824-5p,CNT2086209,0,3,4,-4,3
12,ath-miR834,CNT2086194,1,4,5,-5,4
13,ath-miR865-5p,CNT2088349,0,5,6,-6,5
根据得到的mirna_dict修改该csv文件中的mirna_id，使得每一个mirna与其字典中对应的值相同
要根据已有的字典将CSV文件中的’mirna_id’列与字典中对应的值相匹配，可以使用以下代码：

import csv

mirna_dict = {
    'ath-miR5020a': 1,
    'ath-miR403-5p': 2,
    'ath-miR164c-5p': 3,
    'ath-miR824-5p': 4,
    'ath-miR834': 5,
    'ath-miR865-5p': 6
}

# 读取CSV文件并修改'mirna_id'
with open('your_csv_file.csv', 'r') as file:
    reader = csv.DictReader(file)
    rows = list(reader)

for row in rows:
    mirna = row['mirna']
    mirna_id = mirna_dict.get(mirna)
    if mirna_id is not None:
        row['mirna_id'] = mirna_id

# 保存修改后的CSV文件
fieldnames = ['Unnamed: 0', 'mirna', 'lncrna', 'Label', 'pair_index', 'mirna_id', 'lncrna_id', 'pair_id']
with open('updated_csv_file.csv', 'w', newline='') as file:
    writer = csv.DictWriter(file, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerows(rows)

请将代码中的 'your_csv_file.csv' 替换为实际的CSV文件名，并根据已有的mirna字典修改 mirna_dict 的内容。

代码首先读取CSV文件，并将每行的数据存储在一个字典中。然后，遍历每行数据，根据’mirna’列的值从字典中获取对应的’mirna_id’值，并更新该行数据中的’mirna_id’列。

最后，将修改后的数据写入到一个新的CSV文件（‘updated_csv_file.csv’）中，并保持原始的字段顺序。

运行以上代码后，会生成一个新的CSV文件，其中’mirna_id’列的值已经根据字典进行了更新。

csv.DictReader(file)是使用csv模块提供的DictReader类创建的一个对象。它用于读取CSV文件，并以字典的形式返回每一行的数据。

具体来说，csv.DictReader会自动将CSV文件的第一行解释为字段名，然后将每一行的数据解释为字典，其中字典的键是字段名，字典的值是对应字段的值。

在代码中，csv.DictReader(file)将打开的文件对象file作为参数，创建一个DictReader对象reader。通过reader对象，我们可以逐行迭代读取CSV文件中的数据，并以字典的形式访问每一行的字段值。

以下是一个使用csv.DictReader读取CSV文件的简单示例：

假设我们有一个名为data.csv的CSV文件，内容如下：

name,age,city
John,25,New York
Alice,30,San Francisco
Bob,35,Los Angeles

我们可以使用csv.DictReader来读取该文件，并以字典的形式访问每一行的字段值：

import csv

# 打开CSV文件并创建DictReader对象
with open('data.csv', 'r') as file:
    reader = csv.DictReader(file)

    # 遍历每一行数据
    for row in reader:
        # 访问每个字段的值
        name = row['name']
        age = row['age']
        city = row['city']
        
        # 打印字段值
        print(f"Name: {name}, Age: {age}, City: {city}")

运行上述代码，输出结果如下：

Name: John, Age: 25, City: New York
Name: Alice, Age: 30, City: San Francisco
Name: Bob, Age: 35, City: Los Angeles

在这个示例中，我们打开了名为data.csv的CSV文件，并通过csv.DictReader创建了一个reader对象。然后，我们使用for循环迭代读取每一行的数据，并通过字段名访问每个字段的值。在每次循环中，我们打印了每个字段的值。