English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
紹介
ランダムフォレストを使用してデータの主要な特徴を取得したい
1理論
ランダムフォレストは非常に柔軟な機械学習法であり、幅広い応用前景を持っている。マーケティングから医療保険まで、マーケティングのシミュレーションモデリング、顧客の源の統計、維持と流出を予測することができる。また、疾病のリスクや患者の易感性を予測することもできる；
個体学習器の生成方法に応じて、現在の集成学習法は大きく2つのカテゴリーに分類される。すなわち、個体学習器間に強い依存関係があり、シーケンシャルに生成するシリアライズ方法、および個体学習器間に強い依存関係がない、同時に生成できるパラレル化方法である；
前者的代表是Boosting，后者的代表是Bagging和“随机森林”（Random
Forest）
ランダムフォレストは、決定木を基のBagging集約に基づいて、さらに決定木のトレーニングプロセスにランダムな属性選択（すなわち、ランダムな特徴選択）を導入します。
簡単に言えば、ランダムフォレストは決定木の集約ですが、以下の2点が異なります：
（2）特徴選択の差異：各決定木のn個の分類特徴は、すべての特徴の中でランダムに選択されます（nは自分で調整する必要があります）
ランダムフォレスト、簡単に言えば、salaryの予測などを行う場合、複数の決定木（job、age、house）を構築し、予測する量の各特徴（teacher、39、suburb）はそれぞれの決定木の目標値確率（salary<5000,salary>=5000）、それにより、予測量の発生確率（例えば、P(salary<5000)=0.3）.
ランダムフォレストは、回帰と分類の両方を行うことができます。大規模データを処理する特性を持ち、モデルの基盤データとして非常に重要な変数の推定や予測に役立ちます。
パラメータ説明：
最も重要な二つのパラメータはn_estimatorsとmax_featuresです。
n_estimators：森林内の木の数を示します。理論的には大きい方が良いですが、計算時間の増加が伴います。ただし、大きい方が良いというわけではありません。最も良い予測効果は、合理的な木の数で現れます。
max_features：特徴集合のサブセットをランダムに選択し、節を分割するために使用します。サブセットの数が少ないほど、分散は急速に減少しますが、同時に偏差も急速に増加します。良い経験則に基づいて、回帰問題の場合は：
max_features=n_features、分類問題の場合はmax_features=sqrt(n_features)
良い結果を得るために、max_depth=None、およびmin_sample_split=1。
また、cross_validated（クロスバリデーション）も行うことを忘れないでください。また、ランダムフォレストでは、bootstrap=Trueですが、extra-trees内で、bootstrap=False。
2、ランダムフォレストのPython実装
2.1Demo1
ランダムフォレストの基本機能を実現
#ランダムフォレスト
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
import numpy as np
from sklearn.datasets import load_iris
iris=load_iris()
#print iris#irisの４つの属性は：萼片の幅 萼片の長さ 花びらの幅 花びらの長さ ラベルは花の種類：setosa versicolour virginica
print(iris['target'].shape)
rf=RandomForestRegressor()# ここではデフォルトのパラメータ設定を使用
rf.fit(iris.data[:150],iris.target[:150])# モデルのトレーニングに使用
# 随机に予測結果が異なる2つのサンプルを選択
instance=iris.data[[100,109]
print(instance)
rf.predict(instance[[0]])
print('インスタンス0予測；',rf.predict(instance[[0]]))
print( 'インスタンス 1 予測；',rf.predict(instance[[1]))
print(iris.target[100], iris.target[109)]
実行結果
(150,)
[[ 6.3 3.3 6. 2.5]
[ 7.2 3.6 6.1 2.5]
インスタンス0予測； [ 2．]
インスタンス 1 予測； [ 2．]
2 2
2.2 Demo2
3各方法の比較
# random forest test from sklearn.model_selection import cross_val_score from sklearn.datasets import make_blobs from sklearn.ensemble import RandomForestClassifier from sklearn.ensemble import ExtraTreesClassifier from sklearn.tree import DecisionTreeClassifier X, y = make_blobs(n_samples=10000, n_features=10, centers=100, random_state=0) clf = DecisionTreeClassifier(max_depth=None, min_samples_split=2, random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean()) clf = RandomForestClassifier(n_estimators=10, max_depth=None, min_samples_split=2, random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean()) clf = ExtraTreesClassifier(n_estimators=10, max_depth=None, min_samples_split=2, random_state=0) scores = cross_val_score(clf, X, y) print(scores.mean())
実行結果：
0.979408793821
0.999607843137
0.999898989899
2.3 Demo3-特徴選択を実装します
#ランダムフォレスト2
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
import numpy as np
from sklearn.datasets import load_iris
iris=load_iris()
from sklearn.model_selection import cross_val_score, ShuffleSplit
X = iris["data"]
Y = iris["target"]
names = iris["feature_names"]
rf = RandomForestRegressor()
scores = []
for i in range(X.shape[1]:
score = cross_val_score(rf, X[:, i:i+1], Y, scoring="r2",
cv=ShuffleSplit(len(X), 3, .3))
scores.append((round(np.mean(score), 3), names[i]))
print(sorted(scores, reverse=True))
実行結果：
[(0.89300000000000002, '花びらの幅（cm)'), (0.82099999999999995, '花びらの長さ',
(cm)'), (0.13, '花びらの長さ（cm)'), (-0.79100000000000004, '花びらの幅（cm）')]
2.4 demo4-ランダムフォレスト
以下のコードを使ってランダムフォレスト決定木を構築しようと思いましたが、問題が発生し、プログラムが常に実行中で応答ができませんでした。まだデバッグが必要です。
#ランダムフォレスト4
#coding:utf-8
import csv
from random import seed
from random import randrange
from math import sqrt
def loadCSV(filename):#データをロードし、各行をリストに格納します。
dataSet = []
ファイル名を指定して、'r'モードでファイルをオープンします。
csvReader = csv.reader(file)
for line in csvReader:
dataSet.append(line)
return dataSet
# 除了标签列，其他列都转换为float类型
def column_to_float(dataSet):
featLen = len(dataSet[0]) - 1
for data in dataSet:
for column in range(featLen):
data[column] = float(data[column].strip())
# 将数据集随机分成N块，方便交叉验证，其中一块是测试集，其他四块是训练集
def spiltDataSet(dataSet, n_folds):
fold_size = int(len(dataSet) / n_folds)
dataSet_copy = list(dataSet)
dataSet_spilt = []
for i in range(n_folds):
fold = []
while len(fold) < fold_size: # 这里不能用if，if只是在第一次判断时起作用，while执行循环，直到条件不成立
index = randrange(len(dataSet_copy))
fold.append(dataSet_copy.pop(index)) # pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
dataSet_spilt.append(fold)
return dataSet_spilt
# 构造数据子集
def get_subsample(dataSet, ratio):
subdataSet = []
lenSubdata = round(len(dataSet) * ratio)#返回浮点数
while len(subdataSet) < lenSubdata:
index = randrange(len(dataSet) - 1)
subdataSet.append(dataSet[index])
# print len(subdataSet)
return subdataSet
# 分割数据集
def data_spilt(dataSet, index, value):
left = []
right = []
for row in dataSet:
if row[index] < value:
left.append(row)
else:
right.append(row)
return left, right
# 分割コストを計算
def spilt_loss(left, right, class_values):
loss = 0.0
for class_value in class_values:
left_size = len(left)
if left_size != 0: # 除数が0になるのを防ぐ
prop = [row[-1] for row in left].count(class_value) / float(left_size)
loss += (prop * (1.0 - prop))
right_size = len(right)
if right_size != 0:
prop = [row[-1] for row in right].count(class_value) / float(right_size)
loss += (prop * (1.0 - prop))
return loss
# 任意のn個の特徴量を選択し、そのn個の特徴量から分割時の最適な特徴量を選択
def get_best_spilt(dataSet, n_features):
features = []
class_values = list(set(row[-1for row in dataSet):
b_index, b_value, b_loss, b_left, b_right = 999, 999, 999, None, None
while len(features) < n_features:
index = randrange(len(dataSet[0])) - 1)
if index not in features:
features.append(index)
# print 'features:', features
for index in features: # 次に適切なノードとなる列のインデックス（最小の損失）を見つける
for row in dataSet:
left, right = data_spilt(dataSet, index, row[index]) # そのノードの左右の枝として
loss = spilt_loss(left, right, class_values)
if loss < b_loss: # 検索最小分割コスト
b_index, b_value, b_loss, b_left, b_right = index, row[index], loss, left, right
# print b_loss
# print type(b_index)
return {'index': b_index, 'value': b_value, 'left': b_left, 'right': b_right}
# 出力ラベルの決定
def decide_label(data):
output = [row[-1] for row in data]
return max(set(output), key=output.count)
# 子分割、葉ノードの構築プロセスを繰り返し
def sub_spilt(root, n_features, max_depth, min_size, depth):
left = root['left']
# print left
right = root['right']
del (root['left'])
del (root['right'])
# print depth
if not left or not right:
root['left'] = root['right'] = decide_label(left + right)
# print 'testing'
return
if depth > max_depth:
root['left'] = decide_label(left)
root['right'] = decide_label(right)
return
if len(left) < min_size:
root['left'] = decide_label(left)
else:
root['left'] = get_best_spilt(left, n_features)
# print 'testing_left'
sub_spilt(root['left'], n_features, max_depth, min_size, depth + 1)
if len(right) < min_size:
root['right'] = decide_label(right)
else:
root['right'] = get_best_spilt(right, n_features)
# print 'testing_right'
sub_spilt(root['right'], n_features, max_depth, min_size, depth + 1)
# データセットの決定木の構築
def build_tree(dataSet, n_features, max_depth, min_size):
root = get_best_spilt(dataSet, n_features)
sub_spilt(root, n_features, max_depth, min_size, 1)
return root
# 预测测试集结果
def predict(tree, row):
predictions = []
if row[tree['index']] < tree['value']:
if isinstance(tree['left'], dict):
return predict(tree['left'], row)
else:
return tree['left']
else:
if isinstance(tree['right'], dict):
return predict(tree['right'], row)
else:
return tree['right']
# predictions=set(predictions)
def bagging_predict(trees, row):
predictions = [predict(tree, row) for tree in trees]
return max(set(predictions), key=predictions.count)
# 创建随机森林
def random_forest(train, test, ratio, n_feature, max_depth, min_size, n_trees):
trees = []
for i in range(n_trees):
train = get_subsample(train, ratio)#从切割的数据集中选取子集
tree = build_tree(train, n_features, max_depth, min_size)
# print 'tree %d: '%i,tree
trees.append(tree)
# predict_values = [predict(trees,row) for row in test]
predict_values = [bagging_predict(trees, row) for row in test]
return predict_values
# 正確率を計算
def accuracy(predict_values, actual):
correct = 0
for i in range(len(actual)):
if actual[i] == predict_values[i]:
correct += 1
return correct / float(len(actual))
if __name__ == '__main__':
seed(1)
dataSet = loadCSV(r'G:\0大学院生\tianchiCompetition\訓練小サンプル2.csv')
column_to_float(dataSet)
n_folds = 5
max_depth = 15
min_size = 1
ratio = 1.0
# n_features=sqrt(len(dataSet)-1)
n_features = 15
n_trees = 10
folds = spiltDataSet(dataSet, n_folds)#データセットを分割
scores = []
for fold in folds:
train_set = folds[
:] # ここでは単純にtrain_set=foldsを使用することはできません。このようにすると、train_setの値が変更されると、foldsの値も変更されます。したがって、コピーの形式を使用する必要があります。（L[:]）はシーケンスをコピーし、D.copy()はディクショナリをコピーし、listはリストをコピーします。
train_set.remove(fold)#訓練セットを選択
# print len(folds)
train_set = sum(train_set, []) # 多数のfoldリストをtrain_setリストに結合
# print len(train_set)
test_set = []
for row in fold:
row_copy = list(row)
row_copy[-1] = None
test_set.append(row_copy)
# for row in test_set:
# print row[-1]
actual = [row[-1for row in fold]
predict_values = random_forest(train_set, test_set, ratio, n_features, max_depth, min_size, n_trees)
accur = accuracy(predict_values, actual)
scores.append(accur)
print('木の数は%d' % n_trees)
print('スコア:%s' % scores)
print('平均スコア:%s' % (sum(scores)) / float(len(scores)))
2.5 ランダムフォレスト分類ソニックデータ
# 在Bank Note数据集上应用CART
from random import seed
from random import randrange
from csv import reader
# Load a CSV file
def load_csv(filename):
file = open(filename, "r")
lines = reader(file)
dataset = list(lines)
return dataset
# Convert string column to float
def str_column_to_float(dataset, column):
for row in dataset:
row[column] = float(row[column].strip())
# データセットをk分割に分割します
def cross_validation_split(dataset, n_folds):
dataset_split = list()
dataset_copy = list(dataset)
fold_size = int(len(dataset) / n_folds)
for i in range(n_folds):
fold = list()
while len(fold) < fold_size:
index = randrange(len(dataset_copy))
fold.append(dataset_copy.pop(index))
dataset_split.append(fold)
return dataset_split
# 正確率パーセンテージを計算します
def accuracy_metric(actual, predicted):
correct = 0
for i in range(len(actual)):
if actual[i] == predicted[i]:
correct += 1
return correct / float(len(actual)) * 100.0
# このアルゴリズムをクロスバリデーションスプリットで評価します
def evaluate_algorithm(dataset, algorithm, n_folds, *args):
folds = cross_validation_split(dataset, n_folds)
scores = list()
for fold in folds:
train_set = list(folds)
train_set.remove(fold)
train_set = sum(train_set, [])
test_set = list()
for row in fold:
row_copy = list(row)
test_set.append(row_copy)
row_copy[-1] = None
predicted = algorithm(train_set, test_set, *args)
actual = [row[-1for row in fold]
accuracy = accuracy_metric(actual, predicted)
scores.append(accuracy)
return scores
# データセットを属性と属性値に基づいて分割します
def test_split(index, value, dataset):
left, right = list(), list()
for row in dataset:
if row[index] < value:
left.append(row)
else:
right.append(row)
return left, right
# Calculate the Gini index for a split dataset
def gini_index(groups, class_values):
gini = 0.0
for class_value in class_values:
for group in groups:
size = len(group)
if size == 0:
continue
proportion = [row[-1] for row in group].count(class_value) / float(size)
gini += (proportion * (1.0 - proportion))
return gini
# Select the best split point for a dataset
def get_split(dataset):
class_values = list(set(row[-1] for row in dataset))
b_index, b_value, b_score, b_groups = 999, 999, 999, None
for index in range(len(dataset[0]))-1)
for row in dataset:
groups = test_split(index, row[index], dataset)
gini = gini_index(groups, class_values)
if gini < b_score:
b_index, b_value, b_score, b_groups = index, row[index], gini, groups
print ({'index':b_index, 'value':b_value})
return {'index':b_index, 'value':b_value, 'groups':b_groups}
# 创建终端节点值
def to_terminal(group):
outcomes = [row[-1] for row in group]
return max(set(outcomes), key=outcomes.count)
# Create child splits for a node or make terminal
def split(node, max_depth, min_size, depth):
left, right = node['groups']
del(node['groups'])
# check for a no split
if not left or not right:
node['left'] = node['right'] = to_terminal(left + right)
return
# check for max depth
if depth >= max_depth:
node['left'], node['right'] = to_terminal(left), to_terminal(right)
return
# process left child
if len(left) <= min_size:
node['left'] = to_terminal(left)
else:
node['left'] = get_split(left)
split(node['left'], max_depth, min_size, depth+1)
# process right child
if len(right) <= min_size:
node['right'] = to_terminal(right)
else:
node['right'] = get_split(right)
split(node['right'], max_depth, min_size, depth+1)
# 決定木を構築します
def build_tree(train, max_depth, min_size):
root = get_split(train)
split(root, max_depth, min_size, 1)
return root
# 決定木で予測を行います
def predict(node, row):
if row[node['index']] < node['value']:
if isinstance(node['left'], dict):
return predict(node['left'], row)
else:
return node['left']
else:
if isinstance(node['right'], dict):
return predict(node['right'], row)
else:
return node['right']
# 分类和回归树算法
def decision_tree(train, test, max_depth, min_size):
tree = build_tree(train, max_depth, min_size)
predictions = list()
for row in test:
prediction = predict(tree, row)
predictions.append(prediction)
return(predictions)
# 在Bank Note数据集上测试CART
seed(1)
# 加载并准备数据
filename = r'G:\0pythonstudy\決定樹\sonar.all-data.csv'
dataset = load_csv(filename)
# convert string attributes to integers
for i in range(len(dataset[0]))-1)
str_column_to_float(dataset, i)
# 评估算法
n_folds = 5
max_depth = 5
min_size = 10
scores = evaluate_algorithm(dataset, decision_tree, n_folds, max_depth, min_size)
print('得分: %s' % scores)
print('平均精度: %.3f%%' % (sum(scores)/float(len(scores)))
実行結果：
{'index': 38, 'value': 0.0894}
{'index': 36, 'value': 0.8459}
{'index': 50, 'value': 0.0024}
{'index': 15, 'value': 0.0906}
{'index': 16, 'value': 0.9819}
{'index': 10, 'value': 0.0785}
{'index': 16, 'value': 0.0886}
{'index': 38, 'value': 0.0621}
{'index': 5, 'value': 0.0226}
{'index': 8, 'value': 0.0368}
{'index': 11, 'value': 0.0754}
{'index': 0, 'value': 0.0239}
{'index': 8, 'value': 0.0368}
{'index': 29, 'value': 0.1671}
{'index': 46, 'value': 0.0237}
{'index': 38, 'value': 0.0621}
{'index': 14, 'value': 0.0668}
{'index': 4, 'value': 0.0167}
{'index': 37, 'value': 0.0836}
{'index': 12, 'value': 0.0616}
{'index': 7, 'value': 0.0333}
{'index': 33, 'value': 0.8741}
{'index': 16, 'value': 0.0886}
{'index': 8, 'value': 0.0368}
{'index': 33, 'value': 0.0798}
{'index': 44, 'value': 0.0298}
Scores: [48.78048780487805, 70.73170731707317, 58.536585365853654, 51.2195121951
2195, 39.02439024390244]
Mean Accuracy: 53.659%
請按任意鍵繼續. . .
知识点：
1.load CSV file
from csv import reader # Load a CSV file def load_csv(filename): file = open(filename, "r") lines = reader(file) dataset = list(lines) return dataset filename = r'G:\0pythonstudy\決定樹\sonar.all-data.csv' dataset=load_csv(filename) print(dataset)
2.把数据轉化成float格式
# Convert string column to float def str_column_to_float(dataset, column): for row in dataset: row[column] = float(row[column].strip()) # print(row[column]) # convert string attributes to integers for i in range(len(dataset[0]))-1) str_column_to_float(dataset, i)
3.把最后一列的分类字符串轉化成0、1整数
def str_column_to_int(dataset, column): class_values = [row[column] for row in dataset]#生成一个class label的list # print(class_values) unique = set(class_values)#set 获得list的不同元素 print(unique) lookup = dict()#定義一个字典 # print(enumerate(unique)) for i, value in enumerate(unique): lookup[value] = i # print(lookup) for row in dataset: row[column] = lookup[row[column]] print(lookup['M'])
4、データセットをK分割に分割します
# データセットをk分割に分割します def cross_validation_split(dataset, n_folds): dataset_split = list()#空リストの生成 dataset_copy = list(dataset) print(len(dataset_copy)) print(len(dataset)) #print(dataset_copy) fold_size = int(len(dataset) / n_folds) for i in range(n_folds): fold = list() while len(fold) < fold_size: index = randrange(len(dataset_copy)) # print(index) fold.append(dataset_copy.pop(index))# .pop()を使用して要素をすべて削除（移行に相当します）、これk分割の要素は各々異なる dataset_split.append(fold) return dataset_split n_folds=5 folds = cross_validation_split(dataset, n_folds)#k分割の要素は各々異なるトレーニングセット
5.正確率を計算
# 正確率パーセンテージを計算します def accuracy_metric(actual, predicted): correct = 0 for i in range(len(actual)): if actual[i] == predicted[i]: correct += 1 return correct / float(len(actual)) * 100.0# これは二値分類の正確性の表現です
6.二分分類の各列
# データセットを属性と属性値に基づいて分割します def test_split(index, value, dataset): left, right = list(), list()# 初始化两个空列表 for row in dataset: if row[index] < value: left.append(row) else: right.append(row) return left, right # 返回两个列表，每个列表以value为界限对指定行（index）进行二分类。
7.使用gini系数来获得最佳分割点
# Calculate the Gini index for a split dataset
def gini_index(groups, class_values):
gini = 0.0
for class_value in class_values:
for group in groups:
size = len(group)
if size == 0:
continue
proportion = [row[-1] for row in group].count(class_value) / float(size)
gini += (proportion * (1.0 - proportion))
return gini
# Select the best split point for a dataset
def get_split(dataset):
class_values = list(set(row[-1] for row in dataset))
b_index, b_value, b_score, b_groups = 999, 999, 999, None
for index in range(len(dataset[0]))-1)
for row in dataset:
groups = test_split(index, row[index], dataset)
gini = gini_index(groups, class_values)
if gini < b_score:
b_index, b_value, b_score, b_groups = index, row[index], gini, groups
# print(groups)
print ({'index':b_index, 'value':b_value,'score':gini})
return {'index':b_index, 'value':b_value, 'groups':b_groups}
このコードは、gini指数を求める際に定義式を直接適用しており、理解しやすいです。しかし、最適な分割点を見つけるのは難しいかもしれません。ここでは、二層のループを使用しており、一層は列に対して、もう一層は行に対してループしています。さらに、各ループでgini係数を更新しています。
8、決定木生成
# Create child splits for a node or make terminal def split(node, max_depth, min_size, depth): left, right = node['groups'] del(node['groups']) # check for a no split if not left or not right: node['left'] = node['right'] = to_terminal(left + right) return # check for max depth if depth >= max_depth: node['left'], node['right'] = to_terminal(left), to_terminal(right) return # process left child if len(left) <= min_size: node['left'] = to_terminal(left) else: node['left'] = get_split(left) split(node['left'], max_depth, min_size, depth+1) # process right child if len(right) <= min_size: node['right'] = to_terminal(right) else: node['right'] = get_split(right) split(node['right'], max_depth, min_size, depth+1)
ここでは、再帰プログラミングを使用して、左枝と右枝を繰り返し生成します。
9.決定木を構築します
# 決定木を構築します def build_tree(train, max_depth, min_size): root = get_split(train) split(root, max_depth, min_size, 1) return root tree=build_tree(train_set, max_depth, min_size) print(tree)
10、テストセットを予測します
# 決定木を構築します def build_tree(train, max_depth, min_size): root = get_split(train)# 最良の分割点、インデックス値、グループを取得します split(root, max_depth, min_size, 1) return root # tree=build_tree(train_set, max_depth, min_size) # print(tree) # 決定木で予測を行います def predict(node, row): print(row[node['index']]) print(node['value']) if row[node['index']] < node['value']:# テストセットでトレーニングの最良の分割点を代入し、分割点に偏差がある場合、左右の枝をさらに比較するために検索します。 if isinstance(node['left'], dict):# もし辞書型の場合、操作を実行します return predict(node['left'], row) else: return node['left'] else: if isinstance(node['right'], dict): return predict(node['right'], row) else: return node['right'] tree = build_tree(train_set, max_depth, min_size) predictions = list() for row in test_set: prediction = predict(tree, row) predictions.append(prediction)
11.決定木を評価します
# このアルゴリズムをクロスバリデーションスプリットで評価します def evaluate_algorithm(dataset, algorithm, n_folds, *args): folds = cross_validation_split(dataset, n_folds) scores = list() for fold in folds: train_set = list(folds) train_set.remove(fold) train_set = sum(train_set, []) test_set = list() for row in fold: row_copy = list(row) test_set.append(row_copy) row_copy[-1] = None predicted = algorithm(train_set, test_set, *args) actual = [row[-1for row in fold] accuracy = accuracy_metric(actual, predicted) scores.append(accuracy) return scores
これで本稿の全てが終わりました。皆様の学習に役立つことを願っています。また、呐喊ツアーのサポートを多くお願いします。
声明：本稿の内容はインターネットから収集され、著作権者に帰属します。インターネットユーザーにより自発的に提供されたコンテンツであり、本サイトは権利を保有しておらず、人工編集は行われていません。著作権侵害が疑われる場合は、メールを以下のアドレスまでご送信ください：notice#oldtoolbag.com（メールを送信する際に、#を@に変更してください。侵害を報告する場合、関連する証拠を提供してください。一旦確認がとれましたら、本サイトは侵害された内容をすぐに削除します。）