Применение метода релевантных векторов (ARD) для краткосрочного прогнозирования и анализа финансовых временных рядов

# таблица частот

tmp_df = pd.crosstab(stat_res_1['n_stat'], 'count')

tmp_df['share'] = tmp_df['count']/tmp_df['count'].sum()

tmp_df

При переходе к лог-дохдностям 90% рядов признаются всеми тестами стационарными.

### пример нестационарных рядов (log-доходности)

stat_res_1[stat_res_1['n_stat'] == 0]

### графики нестационарных рядов (log-доходности)

for ticker_name in stat_res_1[stat_res_1['n_stat'] == 0]['ticker']:

y_tmp = pd.read_csv(wd+'ts_data/'+ticker_name+'.csv',

engine = 'python', usecols=['Date', 'Adj Close'],

converters = {'Date': pd.to_datetime}).set_index(['Date'])['Adj Close'].apply(np.log).diff().dropna()

y_tmp.index.name = None

tsplot(y_tmp, lags = 10, ticker_name = ticker_name, save_path = wd+'pict_2/')

### пример стационарных рядов (log-доходности)

stat_res_1[stat_res_1['n_stat'] == 6]

### графики стационарных рядов (log-доходности)

for ticker_name in stat_res_1[stat_res_1['n_stat'] == 6]['ticker'].sample(n = 10):

y_tmp = pd.read_csv(wd+'ts_data/'+ticker_name+'.csv',

engine = 'python', usecols=['Date', 'Adj Close'],

converters = {'Date': pd.to_datetime}).set_index(['Date'])['Adj Close'].apply(np.log).diff().dropna()

y_tmp.index.name = None

tsplot(y_tmp, lags = 10, ticker_name = ticker_name, save_path = wd+'pict_2/')

__Оценка моделей__

### загрузка списка тикеров с готовыми прогнозами

file_list = list(walk(wd+'ard_pred/'))[0][2]

ticker_fin_list = list(map(lambda x: x.split('.')[0], file_list))

del file_list

print(len(ticker_fin_list))

ticker_fin_list[:10]

### загрузка тикеров с ошибками

error_log = pd.read_csv(wd+'ard_pred/error_log.csv', engine = 'python', header = None, sep = ';')

# уникальные ошибки

print(error_log[1].unique())

# список тикеров с известной ошибкой

error_list = error_log[error_log[1] == 'array must not contain infs or NaNs'][0].tolist()

print(len(error_list))

error_list[:10]

### загрузка списка тикеров с готовыми прогнозами

file_list_r = list(walk(wd_r+'auto_arima_predict/'))[0][2]

ticker_fin_list_r = list(map(lambda x: x.split('.')[0], file_list_r))

del file_list_r

print(len(ticker_fin_list_r))

ticker_fin_list_r[:10]

### выгрузка тикеров для R

#pd.DataFrame(ticker_fin_list).to_csv(wd+'ticker_fin_py_1.csv')

### загрузка обработанных тикеров в R

ticker_fin_df_r = pd.read_csv(wd_r+'ticker_fin_r.csv', engine = 'python',

usecols = ['ticker_fin_list'])

print(ticker_fin_df_r.shape)

ticker_fin_df_r.head()

### подвыборка для запуска загрузки

sample = stat_res_1[

(stat_res_1['n_stat'] == 6) & (stat_res_1['ticker'].isin(ticker_fin_list + error_list + drop_list) == False)

]['ticker'].sample(n = 300)

# sample.to_csv(wd+'sample_300.csv', index = False)

sample.head()

%%time

### основной цикл для построения моделей и сохранение результатов

# параметры для построения моделей

L = 5 # максимальный лаг для AR(p)

batch = 30 # длинна рядя для построения модели

# функция для получение df с лагированнйми переменными

def get_lagged_X(y, lag):

return pd.DataFrame([y.shift(l) for l in range(1, lag+1)], index = [y.name+'_l'+str(l) for l in range(1, lag+1)]).T

# функция для получения коэффициентов ARD и прогнозов

def get_ard_results(X, i, ticker_name, batch):

# подвыборка для оценивания

X_batch = X.iloc[(i):(batch + i)]

# оценка модели

ard = ARDRegression(compute_score = True, verbose = False)

ard.fit(X_batch.drop(ticker_name, axis = 1), X_batch[ticker_name])

return pd.DataFrame([np.append(np.append(ard.intercept_, ard.coef_),

ard.predict(X.iloc[batch + i + 1, :].drop(ticker_name).to_frame().T))],

index = [X.iloc[batch + i + 1, :].name],

columns = ['intercept', 'a1', 'a2', 'a3', 'a4', 'a5', 'predict'])

# цикл для стационарных рядов в log-доходностях

for ticker_name in sample: # ticker_fin_df_r['ticker_fin_list']:

try:

# время начала обраотки

#start_time = datetime.now()

# чтение загруженых рядов и расчет log-доходностей

y = pd.read_csv(wd+'ts_data/'+ticker_name+'.csv', engine = 'python',

usecols = ['Date', 'Adj Close'], converters = {'Date': pd.to_datetime}

).set_index('Date')['Adj Close'].apply(np.log).diff().dropna()

y.name = ticker_name

# формирование метрицы признаков

X = y.to_frame().merge(get_lagged_X(y, L), left_index = True, right_index = True).dropna()

# таблица с результатами и исходный ряд log-доходностей

ard_res = pd.concat(Parallel(n_jobs = 3)(delayed(get_ard_results)(X, i, ticker_name, batch)

for i in range(len(X) - batch - 1)))

ard_res.merge(y.to_frame(), how = 'left', left_index = True, right_index = True).to_csv(

wd+'ard_pred/'+ticker_name+'.csv')

# время выполнения

#print('Выполнена обработка ' + ticker_name, '| Время выполнения: ', datetime.now() - start_time)

except Exception as e:

print('Ошибка при обработке ' + ticker_name, '| Текст ошибки: ', str(e))

# запись в таблицу логов

with open(wd+'ard_pred/error_log.csv', 'a', newline='') as f:

csv.writer(f, delimiter = ';').writerow([ticker_name, str(e)])

finally:

pass

# очистка памяти

gc.collect()

### обработка ошибок - ряд с периодами неизменных цен

# чтение загруженых рядов и расчет log-доходностей

y = pd.read_csv(wd+'ts_data/'+'MLPE'+'.csv', engine = 'python',

usecols = ['Date', 'Adj Close'], converters = {'Date': pd.to_datetime}

).set_index('Date')['Adj Close'].apply(np.log).diff().dropna()

y.name = 'MLPE'

y

# формирование метрицы признаков

X = y.to_frame().merge(get_lagged_X(y, L), left_index = True, right_index = True).dropna()

X

#

X.plot(figsize = (15, 5))

plt.show()

__Анализ результатов__

### загрузка списка тикеров с готовыми прогнозами (Python)

file_list = list(walk(wd+'ard_pred/'))[0][2]

ticker_fin_list = list(map(lambda x: x.split('.')[0], file_list))

del file_list

print(len(ticker_fin_list))

ticker_fin_list[:10]

### загрузка списка тикеров с готовыми прогнозами (R)

file_list_r = list(walk(wd_r+'auto_arima_predict/'))[0][2]

ticker_fin_list_r = list(map(lambda x: x.split('.')[0], file_list_r))

del file_list_r

print(len(ticker_fin_list_r))

ticker_fin_list_r[:10]

### формирования итоговой выборки из обработанных тикеров

final_sample = pd.DataFrame(list(set(set(ticker_fin_list) & set(ticker_fin_list_r)) - set(drop_list)),

columns=['ticker']).sample(n = 1000, random_state = 123)

#final_sample.to_csv(wd+'final_sample.csv', index = False)

print(final_sample.shape)

final_sample.head()

### загрузка итогового списка тикеров

final_sample = pd.read_csv(wd+'final_sample.csv', engine = 'python')

print(final_sample.shape)

final_sample.head()

__Сплошной анализ результатов__

def get_pred_stat(ticker_name):

# загрузка прогнозных значений и результатов построения моделей (Python)

res_py = pd.read_csv(wd+'ard_pred/'+ticker_name+'.csv', engine = 'python', converters = {'Unnamed: 0': pd.to_datetime},

usecols = ['Unnamed: 0', ticker_name, 'predict']).rename(columns = {'Unnamed: 0': 'Date'}).set_index('Date')

res_py['eps_py'] = res_py[ticker_name] - res_py['predict']

# загрузка прогнозных значений и результатов построения моделей (R)

res_r = pd.read_csv(wd_r+'auto_arima_predict/'+ticker_name+'.csv',

engine = 'python', converters = {'date': pd.to_datetime}, usecols = ['date', 'predict']

).set_index('date')

# объединение таблиц

res = res_py.merge(res_r, how = 'inner', left_index = True, right_index = True, suffixes = ['_py', '_r'])

res['eps_r'] = res[ticker_name] - res['predict_r']

return {'rmse_py': ((res['eps_py']**2).mean()**(1/2)),

'rmse_r': ((res['eps_r']**2).mean()**(1/2)),

'cor_pred_py': res[[ticker_name, 'predict_py']].corr('pearson').iloc[0, 1],

'cor_pred_r': res[[ticker_name, 'predict_r']].corr('pearson').iloc[0, 1],

'corr_eps': res[['eps_py', 'eps_r']].corr('pearson').iloc[0, 1],

'ts_len': res.shape[0], 'ticker_name': ticker_name}

pred_stat = pd.DataFrame(Parallel(verbose = True, max_nbytes = None, n_jobs = 3)(

delayed(get_pred_stat)(ticker_name) for ticker_name in final_sample['ticker']))

print(pred_stat.shape)

pred_stat.head()

### сохранение результатов сплошного анализа

#pred_stat.to_csv(wd+'pred_stat.csv', index = False)

### загрузка результатов сплошного анализа

pred_stat = pd.read_csv(wd+'pred_stat.csv', engine = 'python')

print(pred_stat.shape)

pred_stat.head()

### визуализация результатов (RMSE)

min_rmse = pred_stat[['rmse_py', 'rmse_r']].min().min()

max_rmse = pred_stat[['rmse_py', 'rmse_r']].max().max()

ticks = np.round([min_rmse+i*(max_rmse-min_rmse)/5 for i in range(6)], 3)

fig, ax = plt.subplots()

pred_stat.rename(columns = {'rmse_py': 'RMSE (Python)', 'rmse_r': 'RMSE (R)', 'ts_len': 'Длинна временного ряда'}

).plot.scatter('RMSE (Python)', 'RMSE (R)', c = 'Длинна временного ряда', cmap = plt.get_cmap('coolwarm'),

figsize = (7, 5), ax = ax, grid = True, xticks = ticks, yticks = ticks)

plt.plot([min_rmse, max_rmse], [min_rmse, max_rmse], ls = '--', c = '.3')

plt.title('Root Mean Squared Error (RMSE)')

plt.show()

### визуализация результатов (Cor)

min_cor_pred = pred_stat[['cor_pred_py', 'cor_pred_r']].min().min()

max_cor_pred = pred_stat[['cor_pred_py', 'cor_pred_r']].max().max()

ticks = np.round([min_cor_pred+i*(max_cor_pred-min_cor_pred)/5 for i in range(6)], 3)

fig, ax = plt.subplots()

pred_stat.rename(columns = {'cor_pred_py': 'Корреляция прогноза (Python)', 'cor_pred_r': 'Корреляция прогноза (R)',

'ts_len': 'Длинна временного ряда'}

).plot.scatter('Корреляция прогноза (Python)', 'Корреляция прогноза (R)',

c = 'Длинна временного ряда', cmap = plt.get_cmap('coolwarm'),

figsize = (7, 5), ax = ax, grid = True, xticks = ticks, yticks = ticks)

plt.plot([min_cor_pred, max_cor_pred], [min_cor_pred, max_cor_pred], ls = '--', c = '.3')

plt.title('Корреляция прогноза и факта')

plt.hlines(y = 0, linestyles = '-', colors = 'black',

xmin = pred_stat['cor_pred_py'].min(), xmax = pred_stat['cor_pred_py'].max())

plt.vlines(x = 0, linestyles = '-', colors = 'black',

ymin = pred_stat['cor_pred_r'].min(), ymax = pred_stat['cor_pred_r'].max())

plt.show()

# визуализация результатов

plt.figure(figsize = (10, 5))

plt.subplots_adjust(wspace = 0.4, hspace = 0.2)

plt.subplot(121)

plt.scatter(pred_stat['ts_len'], pred_stat['cor_pred_py'], alpha = 0.5, label = 'Python')

plt.xlabel('Длинна временного ряда')

plt.ylabel('Коэффициент корреляции')

plt.legend()

plt.legend(loc = 1)

plt.grid()

plt.subplot(122)

plt.scatter(pred_stat['ts_len'], pred_stat['cor_pred_r'], alpha = 0.5, label = 'R', color = 'orange')

plt.xlabel('Длинна временного ряда')

plt.ylabel('Коэффициент корреляции')

plt.legend(loc = 1)

plt.grid()

plt.suptitle('Коэффициент корреляции для прогноза и факта \n в зависимости от длинны временного ряда')

plt.show()

### визуализация результатов (Cor_eps)

plt.scatter(pred_stat['ts_len'], pred_stat['corr_eps'], alpha = 0.5)

plt.hlines(y = 0.6, xmin = pred_stat['ts_len'].min(), xmax = pred_stat['ts_len'].max(), linestyles = '--', lw = 1)

plt.xlabel('Длинна временного ряда')

plt.ylabel('Коэффициент корреляции')

plt.title('Коэффициент корреляции для ошибок \n в зависимости от длинны временного ряда')

plt.grid()

plt.show()

__Детальный анализ отдельных рядов__

## отбор рядов с наибольшей ошибкой

max_rmse_py = pred_stat.sort_values('rmse_py', ascending = False).head(3)

k = 2

ticker_name = max_rmse_py['ticker_name'].iloc[k]

max_rmse_py

### отбор рядов с наименьшей ошибкой

min_rmse_py = pred_stat.sort_values('rmse_py', ascending = True).head(3)

k = 2

ticker_name = min_rmse_py['ticker_name'].iloc[k]

min_rmse_py

### график ряда (в уровнях)

y_tmp = pd.read_csv(wd+'ts_data/'+ticker_name+'.csv',

engine = 'python', usecols=['Date', 'Adj Close'],

converters = {'Date': pd.to_datetime}).set_index(['Date'])['Adj Close']

y_tmp.index.name = None

tsplot(y_tmp, lags = 10, ticker_name = ticker_name, save_path = wd+'pict_1/')

### график ряда (log-доходность)

y_tmp = pd.read_csv(wd+'ts_data/'+ticker_name+'.csv',

engine = 'python', usecols=['Date', 'Adj Close'],

converters = {'Date': pd.to_datetime}).set_index(['Date'])['Adj Close'].apply(np.log).diff().dropna()

y_tmp.index.name = None

tsplot(y_tmp, lags = 10, ticker_name = ticker_name, save_path = wd+'pict_2/')

### загрузка прогнозных значений и результатов построения моделей (Python)

res_py = pd.read_csv(wd+'ard_pred/'+ticker_name+'.csv', engine = 'python', converters = {'Unnamed: 0': pd.to_datetime}

).rename(columns = {'Unnamed: 0': 'Date'}).set_index('Date')

res_py['eps_py'] = res_py[ticker_name] - res_py['predict']

res_py.index.name = None

print(res_py.shape)

res_py.head()

### расчет максмального корня AR(5) полинома

def get_max_abs_root_py(res_row_py):

return np.max(np.absolute(np.roots(np.append(np.array([1]), -1*res_row_py[['a1', 'a2', 'a3', 'a4', 'a5']]))))

res_py['max_abs_root'] = res_py.apply(get_max_abs_root_py, axis = 1)

### moving mean через ar(p) для ARD

def get_ar_mean(row):

try:

return row['intercept'] / (1 - row['a1'] - row['a2'] - row['a3'] - row['a4'] - row['a5'])

except ValueError:

return 0

res_py['mu_py'] = res_py[['a1', 'a2', 'a3', 'a4', 'a5', 'intercept']].apply(lambda row: get_ar_mean(row), axis = 1)

### изменение оценок коэффициентов во времени

res_py[['a1', 'a2', 'a3', 'a4', 'a5', 'intercept']].plot(subplots = True , figsize = (10, 10), alpha = 1, grid = True)

plt.show()

### загрузка прогнозных значений и результатов построения моделей

res_r = pd.read_csv(wd_r+'auto_arima_predict/'+ticker_name+'.csv',

engine = 'python', converters = {'date': pd.to_datetime}

).set_index('date')

res_r.index.name = None

print(res_r.shape)

res_r.head()

### извлечение парметров процесса из текста

# функция для парсинга текста

def proc_from_text(x):

if x == 'numeric(0)':

return {}

else:

d = {}

for s in x[2:-1].replace(' ', '').split(','):

type_, value = s.split('=')

d[type_] = value

return d

# вспомогательная функция

text2table = lambda idx, value: pd.DataFrame(proc_from_text(value[0]), index = [idx])

# получение таблицы

res_r = pd.concat(Parallel(verbose = True, max_nbytes = None, n_jobs = 1)(

delayed(text2table)(idx, value) for idx, value in res_r[['coefs']].iterrows()), sort = False).merge(

res_r, how = 'inner', left_index = True, right_index = True).fillna(0)

# обновление типов данных

res_r = res_r.astype({col:float for col in res_r.columns.drop('coefs')})

res_r.head()

### расчет среднего для ARIMA процессов

# определение столбцов из ar части

ar_cols = []

for col in res_r.columns:

if 'ar' in col:

ar_cols.append(col)

# сумма коэффициентов (вспомогательное поле)

res_r['ar_sum'] = res_r[ar_cols].sum(axis = 1)

def get_arima_mean(x):

if 'drift' in x.index:

if x['intercept'] == 0 and x['drift'] == 0:

return 0

if x['intercept'] != 0 and x['drift'] == 0:

return x['intercept'] / (1 - x['ar_sum'])

elif x['intercept'] == 0 and x['drift'] != 0:

return x['drift'] / (1 - x['ar_sum'])

else:

raise ValueError('Both intercept and drift not 0!')

else:

if x['intercept'] == 0:

return 0

if x['intercept'] != 0:

return x['intercept'] / (1 - x['ar_sum'])

res_r['mu_r'] = res_r.apply(get_arima_mean, axis = 1)

### расчет максимального корня AR(p) полинома для ARIMA(p, d, q)

def get_max_abs_root_r(res_row_r):

return np.max(np.absolute(np.roots(np.append(np.array([1]), -1*res_row_r))))

res_r['max_abs_root'] = res_r.apply(lambda row: get_max_abs_root_r(row[ar_cols]), axis = 1)

### объединение результатов

res = res_py.merge(res_r, how = 'inner', left_index = True, right_index = True, suffixes = ['_py', '_r'])

# расчет ошибки для ARIMA

res['eps_r'] = res[ticker_name] - res['predict_r']

res.head()

### график результатов прогнозирования, оценок мат. ожидания и ошибки

# параметры графика

plt.rcParams.update({'font.size': 25})

fig = plt.figure(figsize = (25, 20))

plt.subplots_adjust(hspace = 0.4, wspace = 0.4)

layout = (3, 3)

# описание размещения графиков

ts_ax_plot = plt.subplot2grid(layout, (0, 0), colspan = 2)

ts_ax_scatter = plt.subplot2grid(layout, (0, 2))

mu_ax_plot = plt.subplot2grid(layout, (1, 0), colspan = 2)

mu_ax_scatter = plt.subplot2grid(layout, (1, 2))

eps_ax_plot = plt.subplot2grid(layout, (2, 0), colspan = 2)

eps_ax_scatter = plt.subplot2grid(layout, (2, 2))

# результат прогноза

res[[ticker_name, 'predict_py', 'predict_r']].plot(ax = ts_ax_plot, alpha = 0.6, grid = True, title = 'Диамика ряда и прогнозов')

res[[ticker_name, 'predict_py', 'predict_r']].plot.scatter(

'predict_py', 'predict_r', ax = ts_ax_scatter, alpha = 0.6, grid = True, c = ticker_name, cmap = plt.get_cmap('coolwarm'))

# оценка среднего

res[['mu_py', 'mu_r']].plot(ax = mu_ax_plot, alpha = 0.6, grid = True, title = 'Динамика среднего')

res[[ticker_name, 'mu_py', 'mu_r']].plot.scatter(

'mu_py', 'mu_r', ax = mu_ax_scatter, alpha = 0.6, grid = True, c = ticker_name, cmap = plt.get_cmap('coolwarm'))

# остатки (прослеживатеся неучтенный GARCH эффект)

res[['eps_py', 'eps_r']].plot(ax = eps_ax_plot, alpha = 0.6, grid = True, title = 'Динамика ошибок')

res[[ticker_name, 'eps_py', 'eps_r']].plot.scatter(

'eps_py', 'eps_r', ax = eps_ax_scatter, alpha = 0.6, grid = True, c = ticker_name, cmap = plt.get_cmap('coolwarm'))

plt.suptitle('Результаты прогнозирования')

plt.savefig(wd+'res.png')

plt.show()

plt.rcParams.update({'font.size': 14})

### график зависимости ошибки от максимального модуля корня полинома

plt.figure(figsize = (15, 5))

plt.subplot(121)

plt.scatter(res['max_abs_root_py'], res['eps_py'].apply(np.abs), label = 'Python: '+ticker_name, alpha = 0.5)

plt.ylabel('Модуль ошибки')

plt.xlabel('Максимальный модуль корня полинома')

plt.legend(loc = 1)

plt.subplot(122)

plt.scatter(res['max_abs_root_r'], res['eps_r'].apply(np.abs), label = 'R: '+ticker_name, alpha = 0.5, color = 'orange')

plt.ylabel('Модуль ошибки')

plt.xlabel('Максимальный модуль корня полинома')

plt.legend(loc = 1)

plt.savefig(wd+'roots.png')

plt.suptitle('Зависимость ошибки от максимального корня')

plt.show()



Приложение №2 - Код на R

### определение рабочей директории

setwd('C:/Users/Роман/Desktop/R/Dissertation/')

### загрузка библиотек

install.packages('quantmod')

quadprog_path = 'https://cran.r-project.org/src/contrib/Archive/quadprog/quadprog_1.5-5.tar.gz'

install.packages(quadprog_path, repos = NULL, type = 'source')

install.packages('forecast')

install.packages('ggplot2')

install.packages('dplyr')

### установка библиотек

library(quantmod)

library(forecast)

library(dplyr)

### количество точек для построения моделей

batch = 30

### загрузка таблицы с названиями тикеров

tickers = read.csv('stac_ts_for_r.csv', colClasses=c(ticker = 'character'))

length(tickers$ticker)

head(tickers)

### функция для загрузки данных, построения моделей и сохранения результатов

get_auto_arima_res <- function(ticker_name) {

# фиксация времени начала обработки

start_time = Sys.time()

# загрузка данных

y = read.csv(paste('C:/Users/Роман/Desktop/Python/Диссертация/ts_data/', ticker_name, '.csv', sep = '')

)[c('Adj.Close', 'Date')]

# изменение типа данных

y <- xts(y$Adj.Close, as.Date(as.character(y$Date), '%Y-%m-%d'))

# расчет log-доходностей

y = na.omit(diff(log(y), 1))

# пустой список для записи результатов

res_list = list()

# цикл оценки моделей и прогнозирования

for (i in 1:(length(y) - batch - 1)) {

# подвыборка для построения модели

y_batch = y[(i):(batch + i - 1)]

# оценка модели

ar = auto.arima(y_batch, trace = FALSE)

# запись результата

res_list = append(res_list,

list(data.frame(date = index(y[batch + i]),

predict = as.character(forecast(ar, h = 1)$mean),

coefs = deparse(ar$coef, width.cutoff = 500)[1])))

}

return(bind_rows(res_list))

}

### функция для получения списка отработаных тикеров

get_ticker_fin_list_r <- function() {

# загрузка списка обработанных файлов

file_list = list.files('C:/Users/Роман/Desktop/R/Dissertation/auto_arima_predict/')

# функция для выделения тикера из названия файла

splitter <- function(s) {strsplit(s, split = '[.]')[[1]][1]}

# извлечение названий

ticker_fin_list_r = mapply(splitter, file_list)

return(ticker_fin_list_r)

}

### параметры запуска джобов

job_number = 1 # номер редактора

n_tickers = round(length(tickers)/2/4) # количество тикеров на исполнении в одном редакторе

# индексы для обработки тикеров

start_idx = (n_tickers*(job_number-1)+1)

end_idx = (n_tickers*job_number)

### основной цикл для загрузки данных, проведения расчета и сохранения результатов

for (ticker_name in tickers$ticker[start_idx:end_idx]) {

if (ticker_name %in% get_ticker_fin_list_r() == FALSE) {

tryCatch(get_auto_arima_res(ticker_name),

error = function(e) {

print(paste('Error in processing:' , ticker_name ,'|',

'Error text:', e))

})

} else {

print(paste(ticker_name, 'обработан ранее!'))

}

}

Размещено на Allbest.ru

...