Магазин Toy&Toy — Super Toys

Врачи всегда писали клинические заметки о своих пациентах — первоначально эти заметки были на бумаге и были заперты в шкафу. К счастью для ученых данных, врачи теперь вносят свои записи в электронную медицинскую карту. Эти заметки представляют собой обширный опыт и знания, которые могут быть использованы для прогнозных моделей с использованием Natural Language Processing (NLP) для улучшения ухода за пациентами и рабочего процесса в больнице.В качестве примера я покажу вам, как прогнозировать повторную госпитализацию с помощью сводных выписок.

Эта статья предназначена для людей, интересующихся наукой о медицинских данных. После завершения этого урока вы изучите

• Как подготовить данные для проекта машинного обучения
• Как предварительно обработать неструктурированные заметки, используя подход с набором слов
• Как построить простую прогностическую модель
• Как оценить качество вашей модели
• Как определить следующий шаг для улучшения модели

Недавно я прочитал эту замечательную статью «Масштабируемое и точное глубокое обучение для электронных медицинских карт», автор Rajkomar et al.(статья на https://arxiv.org/abs/1801.07860). Авторы создали много современных моделей глубокого обучения с данными больниц для прогнозирования внутрибольничной смертности (AUC = 0,93–0,94), 30-дневной незапланированной реадмиссии (AUC = 0,75–76), длительной продолжительности пребывания (AUC). = 0,85–0,86) и диагнозы выписки (AUC = 0,90). AUC является метрикой производительности науки о данных (подробнее об этом ниже), где ближе к 1 лучше. Понятно, что прогнозирование реадмиссии является самой сложной задачей, поскольку у него более низкий AUC. Мне было любопытно, насколько хороша модель, которую мы можем получить, если использовать произвольные текстовые сводки с простой прогностической моделью.

Если вы хотите следовать коду Python в блокноте Jupyter, не стесняйтесь загружать код с моего github.

В этом блоге будет рассказано, как построить классификационную модель для прогнозирования того, какие пациенты подвергаются риску 30-дневной незапланированной реадмиссии, используя сводные выписки из больницы.

Мы будем использовать базу данных MIMIC-III (Медицинский информационный центр для интенсивной терапии III). Эта удивительная бесплатная база данных больниц содержит неопознанные данные более чем 50 000 пациентов, которые были госпитализированы в медицинский центр Beth Israel Deaconess в Бостоне, штат Массачусетс, с 2001 по 2012 год.Чтобы получить доступ к данным этого проекта, вам необходимо запросить доступ по этой ссылке (https://mimic.physionet.org/gettingstarted/access/).

В этом проекте мы будем использовать следующие таблицы MIMIC III

• ADMISSIONS — таблица с датами приема и выписки (имеет уникальный идентификатор HADM_ID для каждого приема)
• NOTEEVENTS — содержит все примечания для каждой госпитализации (ссылки с HADM_ID)

Чтобы сохранить анонимность, все даты были перенесены далеко в будущее для каждого пациента, но время между двумя последовательными событиями для пациента сохраняется в базе данных.Это важно, поскольку оно поддерживает время между двумя госпитализациями для конкретного пациента.

Поскольку это ограниченный набор данных, я не могу публично обмениваться необработанными данными пациентов. В результате я покажу вам только искусственные данные одного пациента или агрегированные описания.

Мы будем следовать приведенным ниже шагам, чтобы подготовить данные из таблиц ADMISSIONS и NOTEEVENTS MIMIC для нашего проекта машинного обучения.

Во-первых, мы загружаем таблицу допусков, используя pandas dataframes:

 # настроить ноутбук 
 для импорта панд как pd 
 для импорта numpy как np 
 import matplotlib.pyplot as plt # читать таблицу допусков 
 df_adm = pd.read_csv ('ADMISSIONS.csv') 

Основные столбцы, представляющие интерес в этой таблице:

• SUBJECT_ID: уникальный идентификатор для каждого субъекта
• HADM_ID: уникальный идентификатор для каждая госпитализация
• ADMITTIME: дата поступления в формате ГГГГ-ММ-ДД чч: мм: сс
• DISCHTIME: дата выписки в том же формате
• DEATHTIME: время смерти (если оно существует) в том же формате
• ADMISSION_TYPE: включает ELECTIVE, Чрезвычайная ситуация, Ньюборн, Срочно

Следующим шагом является преобразование дат из их строкового формата в дату и время.Мы используем флаг errors = ‘coerce’ , чтобы учесть пропущенные даты.

 # преобразовать в даты 
 df_adm.ADMITTIME = pd.to_datetime (df_adm.ADMITTIME, формат = '% Y-% m-% d% H:% M:% S', ошибки = 'принудительно') 
 df_adm.DISCHTIME = pd.to_datetime (df_adm.DISCHTIME, формат = '% Y-% m-% d% H:% M:% S', ошибки = 'coerce') 
 df_adm.DEATHTIME = pd.to_datetime (df_adm.DEATHTIME, формат = '% Y-% m-% d% H:% M:% S', ошибки = 'принудительно') 

Следующим шагом является получение следующей незапланированной даты поступления, если она существует.Это будет сделано в несколько шагов, и я покажу вам, что происходит с искусственным пациентом. Сначала мы отсортируем кадр данных по дате поступления

 # сортируем по subject_ID и дате поступления 
 df_adm = df_adm.sort_values ​​(['SUBJECT_ID', 'ADMITTIME']) 
 df_adm = df_adm.reset_index (drop3 True) 

Мы можем использовать оператор групповой смены, чтобы получить следующий допуск (если он существует) для каждого SUBJECT_ID

 # добавить следующую дату и тип приема для каждого субъекта, используя groupby 
 # Вы должны использовать групповые, иначе даты будут из разных предметов 
 df_adm ['NEXT_ADMITTIME'] = df_adm.groupby ('SUBJECT_ID'). ADMITTIME.shift (-1) # получить следующий тип допуска 
 df_adm ['NEXT_ADMISSION_TYPE'] = df_adm.groupby ('SUBJECT_ID'). ADMISSION_TYPE.shift (-1) 

Обратите внимание, что последний

Обратите внимание, что последний

Обратите внимание, что последний

Обратите внимание, что последний

Обратите внимание, что последний

Обратите внимание, что последний

Обратите внимание, что последний

Обратите внимание, что последний

Обратите внимание, что последний

Обратите внимание, что последний

Обратите внимание, что последний

Примечание, что последний вход не имеет следующего входа.

Но мы хотим предсказать НЕЗАКОННЫЕ повторные зачисления, поэтому нам следует отфильтровать ВЫБОР следующих зачислений.

 # получить строки, в которых следующий допуск является факультативным, и заменить на naT или nan 
 rows = df_adm.NEXT_ADMISSION_TYPE == 'ELECTIVE' 
 df_adm.loc [строки, 'NEXT_ADMITTIME'] = pd.NaT 
 df_adm.loc [ряды, 'NEXT_ADMISSION_TYPE'] = np.NaN 

И затем засыпать значения, которые мы удалили

 # сортировать по subject_ID и дате поступления 
 # это безопаснее сортировать прямо перед заполнением, если что-то изменило порядок выше 
 df_adm = df_adm.sort_values ​​(['SUBJECT_ID', 'ADMITTIME'])) обратная заливка (это займет немного времени) 
 df_adm [['NEXT_ADMITTIME', 'NEXT_ADMISSION_TYPE']] = df_adm.groupby (['SUBJECT_ID']) [['NEXT_ADMITTIME', 'NEXT_ADMISSION_TYPE']].fillna (method = 'bfill') 

Затем мы можем вычислить дни до следующего поступления

 df_adm ['DAYS_NEXT_ADMIT'] = (df_adm.NEXT_ADMITTIME - df_adm.DISCHTIME) .dt *total_seconds () 60) 

В нашем наборе данных с 58976 госпитализациями было 11399 повторных госпитализаций. Для тех, кто с повторным поступлением, мы можем построить гистограмму дней между приемами.

Теперь мы готовы к работе с NOTEEVENTS.csv

 df_notes = pd.read_csv ("NOTEEVENTS.csv") 

Основные интересующие колонки:

• SUBJECT_ID
• HADM_ID
CAT
• 000000 резюме »,« Эхо »,« ЭКГ »,« Уход »,« Врач »,« Реабилитационные услуги »,« Лечение случаев »,« Респираторные операции »,« Питание »,« Общее »,« Социальная работа »,« Аптека », «Consult», «Radiology»,
  «Уход / другое»
• ТЕКСТ: наша колонка клинических заметок

Поскольку я не могу показать отдельные заметки, я просто опишу их здесь.Набор данных имеет 2 083 180 строк, что указывает на наличие нескольких записей на одну госпитализацию. В примечаниях даты и ЗМИ (имя, врач, место нахождения) были преобразованы для обеспечения конфиденциальности. Есть также специальные символы, такие как \ n (новая строка), цифры и знаки препинания.

Поскольку на одну госпитализацию приходится несколько заметок, нам нужно сделать выбор, какие записи использовать. Для простоты давайте воспользуемся сводкой выписок, но мы можем использовать все заметки, объединяя их, если захотим.

 # фильтр для выведения итогов 
 df_notes_dis_sum = df_notes.loc [df_notes.CATEGORY == 'Сводка выписок'] 

Поскольку следующим шагом является объединение заметок в таблице допущений, мы можем предположить, что есть один выпуск резюме за вход, но мы, вероятно, должны проверить это. Мы можем проверить это с помощью утверждения assert, которое в итоге завершается неудачей.

На этом этапе вам может потребоваться выяснить, почему существует несколько сводок, но для простоты давайте просто воспользуемся последним

 df_notes_dis_sum_last = (df_notes_dis_sum.groupby (['SUBJECT_ID', 'HADM_ID']). nth (-1)). reset_index () 
 assert df_notes_dis_sum_last.duplicated (['HADM_ID']). sum () == 0, "Сводка по нескольким выпискам за вход" 

Теперь мы готовы объединить таблицы допусков и заметок. Я использую левое слияние для учета отсутствия заметок. Во многих случаях после слияния вы получаете несколько строк (хотя мы рассматривали это выше), поэтому я хотел бы добавить операторы assert после слияния

 df_adm_notes = pd.merge (df_adm [['SUBJECT_ID', 'HADM_ID ',' ADMITTIME ',' DISCHTIME ',' DAYS_NEXT_ADMIT ',' NEXT_ADMITTIME ',' ADMISSION_TYPE ',' DEATHTIME ']], 
 df_notes_dis_sum_last [[' SUBJECT_ID ']], TID, HID, HID 'SUBJECT_ID', 'HADM_ID'], 
 how = 'left') 
 assent len ​​(df_adm) == len (df_adm_notes), 'Количество строк увеличено' 

10.Отсутствует 6% пропусков ( df_adm_notes.TEXT.isnull (). Sum () / len (df_adm_notes) ), поэтому я провел дальнейшее исследование с

 df_adm_notes.groupby ('ADMISSION_TYPE'). Apply (lambda g) . На данный момент я решил удалить НОВОРОЖДЕННЫЕ. Скорее всего, эти пропущенные при поступлении в NEWBORN сводные данные о выписке хранятся вне набора данных MIMIC.
 
 Для этой проблемы мы собираемся классифицировать, будет ли пациент принят в течение следующих 30 дней. Поэтому нам нужно создать переменную с выходной меткой (1 = повторно принятый, 0 = не принятый) 
 
 df_adm_notes_clean ['OUTPUT_LABEL'] = (df_adm_notes_clean.DAYS_NEXT_ADMIT <30) .astype ('int') 
 Быстрый подсчет положительных и отрицательных результатов в 3004 положительных образцах, 48109 отрицательных образцов. Это указывает на то, что у нас есть несбалансированный набор данных, что является распространенным явлением в науке о данных здравоохранения.
 Последний шаг для подготовки наших данных - это разделение данных на обучающие, проверочные и тестовые наборы. Для воспроизводимых результатов я сделал random_state всегда равным 42.
 # перетасовываем образцы 
 % данных как данные проверки и проверки 
 df_valid_test = df_adm_notes_clean.sample (frac = 0.30, random_state = 42) df_test = df_valid_test.sample (frac = 0.5, random_state = 42) 
 df_valid = df_valid_test.drop (df_test.index) # использовать остальные данные в качестве обучающих данных 
 df_train_all = df_adm_notes_clean.drop (df_valid_test.index) 
, так как низкий показатель Мы хотим, чтобы модель не всегда прогнозировала отрицательное значение (не допускается повторно). Для этого у нас есть несколько вариантов для балансировки обучающих данных
 с дополнительной выборкой негативов
 с дополнительной выборкой позитивов
 создают синтетические данные (например,грамм. SMOTE)
 Поскольку я не устанавливал никаких ограничений на объем оперативной памяти для вашего компьютера, мы отберем негативы, но я рекомендую вам попробовать другие методы, если ваш компьютер или сервер могут с этим справиться, чтобы выяснить, Вы можете получить улучшение. (Опубликуйте комментарий ниже, если вы попробуете это!)loc [~ row_pos] # объединить сбалансированные данные 
 df_train = pd.concat ([df_train_pos, df_train_neg.sample (n = len (df_train_pos), random_state = 42)], axis = 0) # перетасовать порядок обучающих выборок 
 df_train = df_train.sample (n = len (df_train), random_state = 42) .reset_index (drop = True) 

Теперь, когда мы создали наборы данных, которые имеют метку и примечания, нам нужно предварительно обработать наши текстовые данные, чтобы преобразовать их что-то полезное (то есть цифры) для модели машинного обучения. Мы собираемся использовать подход Bag-of-Words (BOW).

BOW в основном разбивает примечание на отдельные слова и подсчитывает, сколько раз встречается каждое слово. Затем ваши числовые данные становятся подсчетами для некоторого набора слов, как показано ниже. BOW - это самый простой способ сделать классификацию НЛП. В большинстве постов в блоге, которые я читал, более сложным методам трудно победить BOW для задач классификации НЛП.

В этом процессе есть несколько вариантов, которые необходимо сделать

• , как предварительно обработать слова
• , как считать слова
• , какие слова использовать

Не существует оптимального выбора для всех проектов НЛП, поэтому Я рекомендую опробовать несколько вариантов при создании собственных моделей.

Вы можете выполнить предварительную обработку двумя способами.

• изменить исходный столбец данных ТЕКСТ.
• - предварительная обработка как часть вашего конвейера, чтобы вы не редактировали исходные данные.

Я покажу вам, как выполнять оба эти но я предпочитаю второй, так как для этого потребовалось много работы.

Давайте определим функцию, которая будет изменять исходный фрейм данных, заполняя пропущенные заметки пробелами и удаляя символы новой строки и возврата каретки.

 def preprocess_text (df): 
 # Эта функция выполняет предварительную обработку текста, заполняя не число и заменяя новые строки (' \ n ') и возврат каретки (' \ r ') 
 df.TEXT = df.TEXT.fillna ('') 
 df.TEXT = df.TEXT.str.replace ('\ n', '') 
 df.TEXT = df.TEXT.str.replace ('\ r', '') 
 return df # предварительно обрабатывает текст для решения известных проблем 
 df_train = preprocess_text (df_train) 
 df_valid = preprocess_text (df_valid) 
 df_test = preprocess_text (df_test) 

Другой вариант - это предварительная обработка как часть процесса. Этот процесс состоит из использования токенизатора и векторизатора. Токенайзер разбивает одну заметку на список слов, а векторизатор берет список слов и считает их.

Мы будем использовать word_tokenize из пакета nltk для нашего токенайзера по умолчанию, который в основном разбивает ноту на основе пробелов и некоторых знаков препинания. Пример показан ниже:

 импорт nltk 
 из nltk import word_tokenize 
 word_tokenize («Это должно быть токенизировано. 02.02.2008 предложение содержит звезды **») 

С выводом:

 ['Это', 'следует ',' be ',' tokenized ','. ', '02 / 02/2018', 'предложение', 
 'имеет', 'звезды **'] 

По умолчанию показано, что некоторые знаки препинания разделены и эти числа остаться в предложении.Мы напишем нашу собственную функцию токенизатора в

• , заменим знаки препинания пробелами
,
• , заменим числа пробелами,
,
• , строчные буквы, все слова
,

, импортируем строку 
. пробелы и строчные все слова 
 punc_list = string.punctuation + '0123456789' 
 t = str.maketrans (dict.fromkeys (punc_list, "")) 
 text = text.lower (). translate (t) 
 tokens = word_tokenize (text) ) 
 возвращаемых токенов 
 

Этот токенизатор мы получаем из нашего исходного предложения

 ['this', 'should', 'be', 'tokenized', 'предложение', 'has', 'stars'] 

Дополнительно все, что вы можете сделать, это лемматизировать или обрезать слова, но это более продвинутый вариант, поэтому я пропущу это.

Теперь, когда у нас есть способ конвертировать свободный текст в токены, нам нужен способ подсчета токенов для каждой сводки выписок. Мы будем использовать встроенный CountVectorizer из пакета scikit-learn. Этот векторизатор просто подсчитывает, сколько раз каждое слово встречается в заметке. Существует также TfidfVectorizer , который учитывает, как часто слова используются во всех заметках, но для этого проекта давайте используем более простую (я получил аналогичные результаты и со второй).

В качестве примера, скажем, у нас есть 3 заметки

 sample_text = ['Наука данных о данных', 'Наука удивительна', 'Прогнозирующее моделирование является частью науки о данных'] 

По сути, вы подходите CountVectorizer, чтобы узнать слова в ваших данных и преобразовать ваши данные, чтобы создать счетчики для каждого слова.

 из sklearn.feature_extraction.text import CountVectorizer 
 vect = CountVectorizer (tokenizer = tokenizer_better) 
 vect.fit (sample_text) # матрица хранится в виде разреженной матрицы (поскольку у вас много нулей) 
 X = vect.transform ( sample_text) 

Матрица X будет разреженной матрицей, но если преобразовать ее в массив ( X.toarray () ), вы увидите этот массив

 ([[1, 0, 2, 1, 0 , 0, 0, 0, 1, 1], 
 [0, 1, 0, 1, 0, 0, 0, 0, 1, 1], 
 [0, 0, 1, 1, 1, 1, 1 , 1, 1, 0]], dtype = int64) 

Где есть 3 строки (так как у нас есть 3 примечания) и количество каждого слова.Вы можете увидеть имена столбцов с помощью vect.get_feature_names ()

 ['about', 'amazing', 'data', 'is', 'моделирование', 'of', 'part', 'Foretive', '' наука ',' the '] 

Теперь мы можем разместить наш CountVectorizer на клинических заметках. Важно использовать только данные обучения, потому что вы не хотите включать какие-либо новые слова, которые появляются в наборах проверки и тестирования. Существует гиперпараметр с именем max_features, который можно установить, чтобы ограничить количество слов, включаемых в векторизатор.Это будет использовать топ N наиболее часто используемых слов. На шаге 5 мы настроим это, чтобы увидеть его эффект.

 # подходит нашему векторизатору. Это займет некоторое время в зависимости от вашего компьютера. from sklearn.feature_extraction.text import CountVectorizer 
 vect = CountVectorizer (max_features = 3000, tokenizer = tokenizer_better) # это может занять некоторое время 
 vect.fit (df_train.TEXT.values) 

Мы можем взглянуть на наиболее часто используемые слова и мы увидим, что многие из этих слов могут не добавить никакой ценности для нашей модели.Эти слова называются стоп-словами, и мы можем легко удалить их (если захотим) с помощью CountVectorizer. Есть списки общих стоп-слов для разных корпусов НЛП, но мы просто составим наш собственный, основываясь на изображении ниже.

 my_stop_words = ['the', 'and', 'to', 'of', 'was', 'with', 'a', 'on', 'in', 'for', 'name', ' is ',' терпеливый ',' s ',' он ',' at ',' as ',' или ',' one ',' she ',' his ',' her ',' am ',' were ' , 'you', 'pt', 'pm', 'by', 'be', 'had', 'your', 'this', 'date', 'from', 'there', 'an', ' что ',' p ',' are ',' have ',' has ',' h ',' but ',' o ',' namepattern ',' which ',' each ',' '' также '] 

Feel можете добавить свои стоп-слова, если хотите.

 из sklearn.feature_extraction.text import CountVectorizer 
 vect = CountVectorizer (max_features = 3000, 
 tokenizer = tokenizer_better, 
 stop_words = my_stop_words) 
 # это может занять некоторое время 
 vect.fit (df_train.TEXT). мы можем преобразовать наши заметки в числовые матрицы. На данный момент я буду использовать только данные обучения и проверки, поэтому я не испытываю желания посмотреть, как они работают с тестовыми данными. 
 
 X_train_tf = vect.transform (df_train.TEXT.values) 
 X_valid_tf = vect.transform (df_valid.TEXT.values) 
 Нам также нужны наши выходные метки в качестве отдельных переменных
 y_train = df_train.OUTPUT_LABEL 
 y_valid = df_valid. полоса прокрутки… как всегда, для подготовки данных для прогнозной модели требуется 80% времени. 
 
 Теперь мы можем построить простую прогностическую модель, которая берет наши входные данные и предсказывает, будет ли пациент повторно принят через 30 дней (ДА = 1, НЕТ = 0).
 
 Здесь мы будем использовать модель логистической регрессии. Логистическая регрессия является хорошей базовой моделью для задач НЛП, поскольку она хорошо работает с разреженными матрицами и интерпретируема. У нас есть несколько дополнительных вариантов (называемых гиперпараметрами), включая C, который является коэффициентом регуляризации и штрафом, который говорит, как измерить регуляризацию. Регуляризация - это техника, позволяющая минимизировать перенастройку. 
 
 # логистическая регрессия 
 из sklearn.linear_model import LogisticRegression 
 clf = LogisticRegression (C = 0.0001, штраф = 'l2', random_state = 42) 
 clf.fit (X_train_tf, y_train) 
 Мы можем рассчитать вероятность повторного пропуска для каждого образца с подобранной моделью
 модель = clf 
 y_train_preds = model.predict_proba (X_train_tf (X_train_tf) ) [:, 1] 
 y_valid_preds = model.predict_proba (X_valid_tf) [:, 1] 
 На данный момент нам необходимо измерить, насколько хорошо работает наша модель. Есть несколько различных метрик производительности науки о данных. Я написал еще одно сообщение в блоге, объясняющее их подробно, если вам интересно.Поскольку этот пост довольно длинный, я начну показывать результаты и цифры. Вы можете увидеть учетную запись github для кода для создания фигур.
 Для
.