def vectword_score(filename, file_save):
with codecs.open(filename, 'r', 'utf-8') as f:
data = [line.strip().split() for line in f.read().split('\n')]
if not data[-1]:
data.pop()
# 每一行为一个短信，值就是TF
t = [Counter(d) for d in data]
v = DictVectorizer()
# 稀疏矩阵表示sparse matrix,词编好号
t = v.fit_transform(t)
TrainData.save(t, file_save)
def vectword():
"""
4.对文本序列化数据建立词向量矩阵
:return:
"""
with codecs.open(dir_path + "/data/tags_token_results", 'r', 'utf-8') as f:
data = [line.strip().split() for line in f.read().split('\n')]
if not data[-1]:
data.pop()
# 每一行为一个短信，值就是TF
t = [Counter(d) for d in data]
v = DictVectorizer()
# 稀疏矩阵表示sparse matrix,词编好号
t = v.fit_transform(t)
TrainData.save(t)
def loss_t_dif(time_dl):
ser2_new = ser2.reindex(ind_1 - BASE_TIME - time_dl, method='ffill')
c = pd.DataFrame(
{
'time': ind_1,
bpm_name: ser1.values,
co_name: ser2_new.values
},
columns=['time', bpm_name, co_name])
val_1val = c.iloc[:, 1].values
val_2val = c.iloc[:, 2].values
ser1_1 = pd.Series(val_1val, index=round(ind_1 - BASE_TIME))
ser1_2 = pd.Series(val_1val, index=round(ind_1 - BASE_TIME - 1))
ser2_1 = pd.Series(val_2val, index=round(ind_1 - BASE_TIME))
ser2_2 = pd.Series(val_2val, index=round(ind_1 - BASE_TIME - 1))
ser1_op = ser1_2 - ser1_1
ser2_op = ser2_2 - ser2_1
dif_df = pd.DataFrame(
{
'time': ser1_op.index,
bpm_name: ser1_op.values,
co_name: ser2_op.values
},
columns=['time', bpm_name, co_name])
print(dif_df)
dif_df = dif_df.dropna(axis=0, how='any')
rangeA = 1
step = 3000
rangeB = rangeA + step
X = dif_df.iloc[rangeA:rangeB, [2]]
y = dif_df.iloc[rangeA:rangeB, [1]]
y_pred, score = TrainData.MLLinearRegression(X, X, y, y)
return (score)
def __init__(self,_params):
self.drive = False
self.log_photos = False
self.train_mode = False
self.current_direction = []
self.name = _params['car_params']['name']
self.width = _params['car_params']['width']
self.height = _params['car_params']['height']
self.verbose = _params['car_params']['verbose']
self.config = _params['car_params']['car_config']
self.channels = _params['car_params']['channels']
self.default_speed = self.config['SPEED']['default']
# Init Trainning mode
if('train_data_params' in _params):
import TrainData
self.train_data = TrainData.TrainData(_params['train_data_params'])
self.train_mode = True
# Init Self-driving mode
if('brain_params' in _params):
from CarBrain import CarBrain
self.brain = CarBrain(_params['brain_params'])
# Init parts
self.init_pins()
self.camera = CarCamera.CarCamera(_params['camera_params'])
def predict(idx):
data, target = TrainData.load(idx)
cls = NaiveBayesian()
train_data = data[:-1]
predict_data = data[-1]
cls.fit(train_data, target)
predicted = cls.predict(predict_data)
return predicted
def predict():
data, target = TrainData.load()
train_data = data[:-1]
predict_data = data[-1]
try:
model = joblib.load(last_path + "/model_classifiers/model_NB.pkl")
predicted = model.predict(predict_data)
except:
model = train_NBmodel(train_data, target)
predicted = model.predict(predict_data)
return predicted
def getTrainData(self,
dateStart=DateTime.datetime.strptime(
"1980/01/01", '%Y/%m/%d').date(),
dateEnd=DateTime.date.today()):
trainData = []
#stock by stock取数
for stock in self.stocks:
stock.days = sorted(stock.days, key=lambda day: day.date)
#使用index一天天取数
for index in range(len(stock.days) - 1):
if stock.days[index].date >= dateStart and stock.days[
index].date < dateEnd: #取在时间范围内的数据
oneTrain = TrainData.TrainData(stock.days[index],
stock.days[index + 1])
if (len(oneTrain.data) == 240):
trainData.append(oneTrain)
return trainData
def predict_score(sub, model):
save_price_path = '../data/tags_' + sub + '_results'
data, target = TrainData.load_model(save_price_path + '_tag',
'../model/' + sub + '_train_data.pkl')
train_data = data[:-1]
predict_data = data[-1]
if model == 'KNN':
model = knn_classifier(train_data, target)
elif model == 'LR':
model = logistic_regression_classifier(train_data, target)
elif model == 'RF':
model = random_forest_classifier(train_data, target)
elif model == 'DT':
model = decision_tree_classifier(train_data, target)
else:
model = gradient_boosting_classifier(train_data, target)
predicted = model.predict(predict_data)
return predicted[0] + 1
def predict_score(sub, m):
save_price_path = last_path + '/data/tags_' + sub + '_results'
data, target = TrainData.load_model(
save_price_path + '_tag',
last_path + '/model/' + sub + '_train_data.pkl')
train_data = data[:-1]
predict_data = data[-1]
try:
model = joblib.load(last_path + "/model_classifiers/model" + sub +
"_LR.pkl")
predicted = model.predict(predict_data)
except:
if m == 'KNN':
model = knn_classifier(train_data, target)
elif m == 'LR':
model = logistic_regression_classifier(train_data, target)
elif m == 'RF':
model = random_forest_classifier(train_data, target)
elif m == 'DT':
model = decision_tree_classifier(train_data, target)
else:
model = gradient_boosting_classifier(train_data, target)
predicted = model.predict(predict_data)
return predicted[0] + 1
#! /usr/bin/python3
import sys
sys.path.append("./function")
import tensorflow as tf
import TrainData
# 定义数据
myLen = 500
w_true = TrainData.getRandomList(myLen, 1)
# 已知的输入输出
x_train = tf.placeholder(shape=[myLen], dtype=tf.float32)
y_train = tf.placeholder(shape=[], dtype=tf.float32)
# 定义权重，预测输出函数，误差，训练方向
w = tf.Variable(tf.zeros([myLen]), dtype=tf.float32)
y = tf.reduce_sum(x_train*w)
loss = tf.abs(y-y_train)
optimizer = tf.train.RMSPropOptimizer(0.001)
train = optimizer.minimize(loss)
# 初始化训练
init = tf.global_variables_initializer()
sess = tf.Session(config=config)
sess.run(init)
#开始训练
loss_value = 0
for i in range(1000):
myData = TrainData.getTrainData(myLen, w_true)
def train(self): self.train_data_params['car'] = self self.train_data = TrainData.TrainData(self.train_data_params)
save_length = 0
total_data = 0
write_list = []
file = open('training_data.txt', 'a')
#caminfo = 88.0000991821289, -449.00006103515625, 5.179999828338623, (0.26104751229286194, 0.9333941340446472, 13.440003395080566)
# yaw, pitch, dist, target
#def test():
# print(p.getDebugVisualizerCamera())
#
#t = Timer(15.0, test)
#t.start()
nn_direction, nn_velocity = TrainData.get_train_weights(100)
print()
while 1:
sensors_list = np.transpose(
np.array([robot.get_output_sensor_for_near_road_points(road)[1:5]]))
if sensors_list.shape[0] == 4:
output_sensor_direction = np.transpose(
nn_direction.model_output(sensors_list))[0]
output_sensor_velocity = np.transpose(
nn_velocity.model_output(sensors_list))[0]
if output_sensor_direction[0] > output_sensor_direction[1]:
def train_NBmodel(train_data, target):
model = NaiveBayesian()
model.fit(train_data, target)
TrainData.save(model, last_path + "/model_classifiers/model_NB.pkl")
return model
print(trainData.shape)
weightData = np.random.rand(2, 650)
iteration = 600
learningRate = 0.6
#patientNoEmptyValues = np.array(patientData[patientData!=0])
#patieNotZeros = np.argwhere(patientData)
fig = plt.figure(figsize=(20, 10))
figp = fig.subplots(2, 2, gridspec_kw={'width_ratios': [8, 3]})
figp[0, 0].imshow(trainData[15:16, 20:30])
weightDataEnd = Train.trainData(weightData, trainData, iteration, learningRate)
print(weightData[1, 25])
figp[0, 1].imshow(weightDataEnd[1:2, 20:30])
"""
for i in range(int(patientData.shape[1]/10.0)):
figp[0,0].imshow(patientData[0:2,i+10:i+20])
plt.pause(0.1)
i = i + 10
"""
print("TESTING.................")
testData = trainData[1]
def test():
np.random.seed(0) # Seed the random number generator
# p["Data"]["LoadFromCache"] = True
# p["Kmean"]["LoadFromCache"] = True
# p["DataProcess"]["LoadFromCache"] = True
folderList = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
images, labels = GetData.get_data(p['Data'], folderList)
image_features = DataPreper.data_prepare(p['DataProcess'], images)
train_x_array, train_y_array, test_x_array, test_y_array = SplitData.split_data_train_test(
p['Split'], image_features)
linear_svms = []
poly_svms = []
decisions_array = []
decisions_poly_array = []
for i in range(-5, 15):
p["Train"]["C_Value"] = np.float_power(10, i)
linear_svm = TrainData.train_data_linear(p['Train'], train_x_array,
train_y_array)
poly_svms = TrainData.train_data_non_linear(p['Train'], train_x_array,
train_y_array)
decisions = TestData.test_linear_svm(p['Test'], linear_svm, test_x_array,
test_y_array)
decisions_poly = TestData.test_poly_svm(p['Test'], poly_svms, test_x_array,
test_y_array)
linear_svms.append(linear_svm)
decisions_array.append(decisions)
decisions_poly_array.append(decisions_poly)
save_length = 0
total_data = 0
write_list = []
file = open('training_data.txt', 'a')
#caminfo = 88.0000991821289, -449.00006103515625, 5.179999828338623, (0.26104751229286194, 0.9333941340446472, 13.440003395080566)
# yaw, pitch, dist, target
#def test():
# print(p.getDebugVisualizerCamera())
#
#t = Timer(15.0, test)
#t.start()
nn = TrainData.get_train_weights()
print()
while 1:
sensors_list = robot.get_output_sensor_for_near_road_points(road)
output_sensor = np.transpose(
nn.model_output(
np.transpose(
np.array(
robot.get_output_sensor_for_near_road_points(road)[1:5]))))
is_right = 0
is_left = 0
is_forward = 0
