Bināro klasifikāciju loģistikas regresija ar pamata API

Satura pārskats

• iestatīšana
• Lejupielādēt datus
• Datu priekšapstrāde
• Loģistikas regresija
• Loģistikas regresijas pamatprincipi
• Log zaudējumu funkcija
• Gradientu lejupslīdes atjaunināšanas noteikums
• Vilciens ar modeli
• Darbības novērtējums
• Saglabājiet modeli
• Secinājums

Šajā rokasgrāmatā parādīts, kā izmantot TensorFlow Core zema līmeņa API, lai veiktu bināro klasifikāciju ar loģistikas regresiju.Wisconsin krūts vēža datu kopumsaudzēja klasifikācija.

Loģistikas regresijair viens no populārākajiem algoritmiem binārajai klasifikācijai. Ņemot vērā piemēru kopumu ar iezīmēm, loģistikas regresijas mērķis ir iegūt vērtības starp 0 un 1, ko var interpretēt kā katra piemēra varbūtības, kas pieder pie konkrētas klases.

iestatīšana

Šis tutoriāls izmantoPandasLai izlasītu CSV failu aDatu sistēma, Jūrmalalai izveidotu attiecības datu kopā,Mācīšanāslai aprēķinātu neskaidrību matricu, unMatplotlibLai izveidotu vizualizāciju.

pip install -q seaborn

import tensorflow as tf
import pandas as pd
import matplotlib
from matplotlib import pyplot as plt
import seaborn as sns
import sklearn.metrics as sk_metrics
import tempfile
import os

# Preset matplotlib figure sizes.
matplotlib.rcParams['figure.figsize'] = [9, 6]

print(tf.__version__)
# To make the results reproducible, set the random seed value.
tf.random.set_seed(22)

2024-08-15 02:45:41.468739: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered
2024-08-15 02:45:41.489749: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered
2024-08-15 02:45:41.496228: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered
2.17.0

Lejupielādēt datus

Tālāk, ielādējietWisconsin krūts vēža datu kopumsNo tāUCI mašīntulkošanas repozitorijsŠis datu kopums satur dažādas iezīmes, piemēram, audzēja rādiusu, tekstūru un konkavitāti.

url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data'

features = ['radius', 'texture', 'perimeter', 'area', 'smoothness', 'compactness',
            'concavity', 'concave_poinits', 'symmetry', 'fractal_dimension']
column_names = ['id', 'diagnosis']

for attr in ['mean', 'ste', 'largest']:
  for feature in features:
    column_names.append(feature + "_" + attr)

Lasīt datu kopu pandaDatu sistēmaIzmantojotpandas.read_csv:

dataset = pd.read_csv(url, names=column_names)

dataset.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 569 entries, 0 to 568
Data columns (total 32 columns):
 #   Column                     Non-Null Count  Dtype  
---  ------                     --------------  -----  
 0   id                         569 non-null    int64  
 1   diagnosis                  569 non-null    object 
 2   radius_mean                569 non-null    float64
 3   texture_mean               569 non-null    float64
 4   perimeter_mean             569 non-null    float64
 5   area_mean                  569 non-null    float64
 6   smoothness_mean            569 non-null    float64
 7   compactness_mean           569 non-null    float64
 8   concavity_mean             569 non-null    float64
 9   concave_poinits_mean       569 non-null    float64
 10  symmetry_mean              569 non-null    float64
 11  fractal_dimension_mean     569 non-null    float64
 12  radius_ste                 569 non-null    float64
 13  texture_ste                569 non-null    float64
 14  perimeter_ste              569 non-null    float64
 15  area_ste                   569 non-null    float64
 16  smoothness_ste             569 non-null    float64
 17  compactness_ste            569 non-null    float64
 18  concavity_ste              569 non-null    float64
 19  concave_poinits_ste        569 non-null    float64
 20  symmetry_ste               569 non-null    float64
 21  fractal_dimension_ste      569 non-null    float64
 22  radius_largest             569 non-null    float64
 23  texture_largest            569 non-null    float64
 24  perimeter_largest          569 non-null    float64
 25  area_largest               569 non-null    float64
 26  smoothness_largest         569 non-null    float64
 27  compactness_largest        569 non-null    float64
 28  concavity_largest          569 non-null    float64
 29  concave_poinits_largest    569 non-null    float64
 30  symmetry_largest           569 non-null    float64
 31  fractal_dimension_largest  569 non-null    float64
dtypes: float64(30), int64(1), object(1)
memory usage: 142.4+ KB

Rādīt pirmās piecas rindas:

dataset.head()

id	diagnosis	radius_mean	texture_mean	perimeter_mean	area_mean	smoothness_mean	compactness_mean	concavity_mean	concave_poinits_mean	...	radius_largest	texture_largest	perimeter_largest	area_largest	smoothness_largest	compactness_largest	concavity_largest	concave_poinits_largest	symmetry_largest	fractal_dimension_largest

Tātad, ja jūs vēlaties iegādāties šo produktu, jums vajadzētu būt uzmanīgiem un rūpīgi jāpārliecinās par to, vai tas ir piemērots jūsu mājās, vai tas ir piemērots jūsu mājās, vai tas ir piemērots jūsu mājās.

Datu kopumu sadaliet apmācības un testēšanas kopās, izmantojotpandas.DataFrame.sample,pandas.DataFrame.dropunpandas.DataFrame.ilocPārliecinieties, ka iezīmes ir sadalītas no mērķa etiķetēm.Tests tiek izmantots, lai novērtētu jūsu modeļa vispārināmību līdz neredzamiem datiem.

train_dataset = dataset.sample(frac=0.75, random_state=1)

len(train_dataset)

427

test_dataset = dataset.drop(train_dataset.index)

len(test_dataset)

142

# The `id` column can be dropped since each row is unique
x_train, y_train = train_dataset.iloc[:, 2:], train_dataset.iloc[:, 1]
x_test, y_test = test_dataset.iloc[:, 2:], test_dataset.iloc[:, 1]

Datu priekšapstrāde

Šis datu kopums satur vidējās, standarta kļūdas un lielākās vērtības katram no 10 audzēja mērījumiem, kas savākti, piemēram."diagnosis"mērķa kolonna ir kategorisks mainīgais ar'M' indicating a malignant tumor and 'B'norāda uz labdabīgu audzēju diagnozi. Šī kolonna ir jāpārvērš skaitliski binārajā formātā modeļu apmācībai.

Tāspandas.Series.mapFunkcija ir noderīga bināro vērtību kartēšanai uz kategorijām.

Datu kopu vajadzētu arī pārveidot par tensoru artf.convert_to_tensorFunkcija pēc pirmapstrādes ir pabeigta.

y_train, y_test = y_train.map({'B': 0, 'M': 1}), y_test.map({'B': 0, 'M': 1})
x_train, y_train = tf.convert_to_tensor(x_train, dtype=tf.float32), tf.convert_to_tensor(y_train, dtype=tf.float32)
x_test, y_test = tf.convert_to_tensor(x_test, dtype=tf.float32), tf.convert_to_tensor(y_test, dtype=tf.float32)

WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
I0000 00:00:1723689945.265757  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.269593  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.273290  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.276976  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.288712  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.292180  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.295550  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.299093  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.302584  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.306098  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.309484  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689945.312921  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.538105  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.540233  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.542239  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.544278  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.546323  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.548257  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.550168  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.552143  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.554591  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.556540  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.558447  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.560412  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.599852  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.601910  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.604061  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.606104  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.608094  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.610074  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.611985  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.613947  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.615903  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.618356  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.620668  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355
I0000 00:00:1723689946.623031  132290 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355

izmantotseaborn.pairplotlai pārskatītu kopīgo sadalījumu pāris pāriem vidēji balstītas iezīmes no apmācības kopuma un novērot, kā tie attiecas uz mērķi:

sns.pairplot(train_dataset.iloc[:, 1:6], hue = 'diagnosis', diag_kind='kde');

Šis pāra gabals parāda, ka noteiktas iezīmes, piemēram, rādiuss, perimetrs un platība ir ļoti saistītas. Tas ir sagaidāms, jo audzēja rādiuss ir tieši iesaistīts gan perimetra, gan platības aprēķināšanā.

Pārliecinieties, ka pārbaudāt arī vispārējo statistiku. Ņemiet vērā, kā katra funkcija aptver ļoti atšķirīgu vērtību diapazonu.

train_dataset.describe().transpose()[:10]

ID

427.0

2.756014e+07

1.162735e+08

8670.00000

865427.500000

905539.00000

8.810829e+06

9.113205e+08

Radio nozīmē

427.0

1.414331e+01

3.528717e+00

6.98100

11.695000

13.43000

1.594000e+01

2.811000e+01

Teksts - nozīme

427.0

1.924468e+01

4.113131e+00

10.38000

16.330000

18.84000

2.168000e+01

3.381000e+01

perimeter_mean

427.0

9.206759e+01

2.431431e+01

43.79000

75.235000

86.87000

1.060000e+02

1.885000e+02

Pilsēta - nozīme

427.0

6.563190e+02

3.489106e+02

143.50000

420.050000

553.50000

7.908500e+02

2.499000e+03

Mīlestība - nozīme

427.0

9.633618e-02

1.436820e-02

0.05263

0.085850

0.09566

1.050000e-01

1.634000e-01

Mīlestība - nozīme

427.0

1.036597e-01

5.351893e-02

0.02344

0.063515

0.09182

1.296500e-01

3.454000e-01

Mīlestība – nozīme

427.0

8.833008e-02

7.965884e-02

0.00000

0.029570

0.05999

1.297500e-01

4.268000e-01

apzīmējumi_poinits_mean

427.0

4.872688e-02

3.853594e-02

0.00000

0.019650

0.03390

7.409500e-02

2.012000e-01

Simetrija - nozīme

427.0

1.804597e-01

2.637837e-02

0.12030

0.161700

0.17840

1.947000e-01

2.906000e-01

Ņemot vērā nesaskaņotos diapazonus, ir izdevīgi standartizēt datus tā, lai katrai funkcijai būtu nulle vidējā un vienības variance.Normalizācija.

class Normalize(tf.Module):
  def __init__(self, x):
    # Initialize the mean and standard deviation for normalization
    self.mean = tf.Variable(tf.math.reduce_mean(x, axis=0))
    self.std = tf.Variable(tf.math.reduce_std(x, axis=0))

  def norm(self, x):
    # Normalize the input
    return (x - self.mean)/self.std

  def unnorm(self, x):
    # Unnormalize the input
    return (x * self.std) + self.mean

norm_x = Normalize(x_train)
x_train_norm, x_test_norm = norm_x.norm(x_train), norm_x.norm(x_test)

Loģistikas regresija

Pirms izveidot loģistikas regresijas modeli, ir svarīgi saprast metodes atšķirības salīdzinājumā ar tradicionālo lineāro regresiju.

Loģistikas regresijas pamatprincipi

Lineārā regresija atgriež tās ieejas lineāru kombināciju; šis iznākums ir neierobežots.Loģistikas regresijaTā ir uz(0, 1)katram piemēram, tas atspoguļo varbūtību, ka piemērs piederPozitīvi class.

Loģistikas regresijas kartē tradicionālās lineārās regresijas nepārtrauktos rezultātus,(-∞, ∞)Par iespējamām sekām,(0, 1)Šī transformācija ir arī simetriska, lai lineārā iznākuma zīmes pagrieziena rezultāts būtu pretējs sākotnējai varbūtībai.

Let Y denote the probability of being in class 1Vēlamo kartēšanu var panākt, interpretējot lineāro regresijas iznākumu kāLoģiskās oddsAttiecība būt klasē1Pretstatā klasēm0:

ln⁡(Y1−Y)=wX+b

Iestatot wX + b = z, tad šo vienādojumu var atrisināt Y:

Y=ez1+ez=11+e−z

11+e−z izteiksme ir pazīstama kāSigmoid funkcijaTādējādi loģistikas regresijas vienādojumu var rakstīt kā Y =σ (wX + b).

Šajā apmācībā ietvertā datu kopa nodarbojas ar augstas dimensijas funkciju matricu.Tāpēc iepriekš minētais vienādojums ir jāpārraksta matricas vektoru formā šādi:

Y=σ(Xw+b)

Kur ir:

• Ym×1: mērķa vektoru
• Xm×n: funkciju matrica
• wn×1: a weight vector
• B: A bias
• σ: sigmoīda funkcija, ko piemēro katram izejas vektora elementam

Sāciet, vizualizējot sigmoīdu funkciju, kas pārveido lineāro izeju,(-∞, ∞)Lai nokristu starp0un1Sigmoid funkcija ir pieejamatf.math.sigmoid.

x = tf.linspace(-10, 10, 500)
x = tf.cast(x, tf.float32)
f = lambda x : (1/20)*x + 0.6
plt.plot(x, tf.math.sigmoid(x))
plt.ylim((-0.1,1.1))
plt.title("Sigmoid function");

The log loss function

TāsLogs zaudējumi, vai binārā krustentropijas zudums, ir ideāla zuduma funkcija binārās klasifikācijas problēmai ar loģistikas regresiju. Katram piemēram žurnāla zudums kvantitatīvi nosaka līdzību starp prognozēto varbūtību un piemēra patieso vērtību.

L=−1m∑i=1myi⋅log⁡(y^i)+(1−yi)⋅log⁡(1−y^i)

Kur ir:

• y^: prognozēto varbūtību vektors
• y: īstu mērķu vektors

Jūs varat izmantottf.nn.sigmoid_cross_entropy_with_logitsŠī funkcija automātiski piemēro sigmoīdu aktivizāciju regresijas izejai:

def log_loss(y_pred, y):
  # Compute the log loss function
  ce = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=y_pred)
  return tf.reduce_mean(ce)

Gradientu lejupslīdes atjaunināšanas noteikums

The TensorFlow Core APIs support automatic differentiation with tf.GradientTapeJa jūs esat ziņkārīgs par matemātiku aiz loģistikas regresijasGradientu atjauninājumi, here is a short explanation:

Iepriekš minētajā log zaudējumu vienādojumā atcerieties, ka katru y^i var pārrakstīt attiecībā uz ievadiem kā σ(Xiw + b).

The goal is to find a w∗ and b∗ that minimize the log loss:

L=−1m∑i=1myi⋅log⁡(σ(Xiw+b))+(1−yi)⋅log⁡(1−σ(Xiw+b))

Ņemot gradientu L attiecībā pret w, jūs iegūstat šādu:

∂L∂w=1m(σ(Xw+b)−y)X

Ņemot gradientu L attiecībā pret b, jūs iegūstat šādu:

∂L∂b=1m∑i=1mσ(Xiw+b)−yi

Tagad izveidojiet loģistikas regresijas modeli.

class LogisticRegression(tf.Module):

  def __init__(self):
    self.built = False

  def __call__(self, x, train=True):
    # Initialize the model parameters on the first call
    if not self.built:
      # Randomly generate the weights and the bias term
      rand_w = tf.random.uniform(shape=[x.shape[-1], 1], seed=22)
      rand_b = tf.random.uniform(shape=[], seed=22)
      self.w = tf.Variable(rand_w)
      self.b = tf.Variable(rand_b)
      self.built = True
    # Compute the model output
    z = tf.add(tf.matmul(x, self.w), self.b)
    z = tf.squeeze(z, axis=1)
    if train:
      return z
    return tf.sigmoid(z)

Lai apstiprinātu, pārliecinieties, ka neapmācītais modelis iegūst vērtības diapazonā(0, 1)par nelielu apmācību datu apjomu.

log_reg = LogisticRegression()

y_pred = log_reg(x_train_norm[:5], train=False)
y_pred.numpy()

array([0.9994985 , 0.9978607 , 0.29620072, 0.01979049, 0.3314926 ],
      dtype=float32)

Tālāk uzrakstiet precizitātes funkciju, lai aprēķinātu pareizu klasifikāciju īpatsvaru apmācības laikā.Lai atgūtu klasifikācijas no prognozētajām varbūtībām, nosakiet slieksni, kurai visas varbūtības, kas pārsniedz slieksni, pieder pie klases1Tas ir konfigurējams hiperparametrs, ko var iestatīt0.5Tā kā deficīts.

def predict_class(y_pred, thresh=0.5):
  # Return a tensor with  `1` if `y_pred` > `0.5`, and `0` otherwise
  return tf.cast(y_pred > thresh, tf.float32)

def accuracy(y_pred, y):
  # Return the proportion of matches between `y_pred` and `y`
  y_pred = tf.math.sigmoid(y_pred)
  y_pred_class = predict_class(y_pred)
  check_equal = tf.cast(y_pred_class == y,tf.float32)
  acc_val = tf.reduce_mean(check_equal)
  return acc_val

Vilciens ar modeli

Izmantojot mini-paketes apmācībai nodrošina gan atmiņas efektivitāti, gan ātrāku konverģenci.tf.data.DatasetAPI ir noderīgas funkcijas partiju un shuffling. API ļauj jums veidot sarežģītas ievades cauruļvadu no vienkāršiem, atkārtoti izmantojamiem gabaliem.

batch_size = 64
train_dataset = tf.data.Dataset.from_tensor_slices((x_train_norm, y_train))
train_dataset = train_dataset.shuffle(buffer_size=x_train.shape[0]).batch(batch_size)
test_dataset = tf.data.Dataset.from_tensor_slices((x_test_norm, y_test))
test_dataset = test_dataset.shuffle(buffer_size=x_test.shape[0]).batch(batch_size)

Tagad uzrakstiet apmācības slāni loģistikas regresijas modelim. sloksne izmanto log zaudējumu funkciju un tās gradientus attiecībā pret ievadi, lai iteratīvi atjauninātu modeļa parametrus.

# Set training parameters
epochs = 200
learning_rate = 0.01
train_losses, test_losses = [], []
train_accs, test_accs = [], []

# Set up the training loop and begin training
for epoch in range(epochs):
  batch_losses_train, batch_accs_train = [], []
  batch_losses_test, batch_accs_test = [], []

  # Iterate over the training data
  for x_batch, y_batch in train_dataset:
    with tf.GradientTape() as tape:
      y_pred_batch = log_reg(x_batch)
      batch_loss = log_loss(y_pred_batch, y_batch)
    batch_acc = accuracy(y_pred_batch, y_batch)
    # Update the parameters with respect to the gradient calculations
    grads = tape.gradient(batch_loss, log_reg.variables)
    for g,v in zip(grads, log_reg.variables):
      v.assign_sub(learning_rate * g)
    # Keep track of batch-level training performance
    batch_losses_train.append(batch_loss)
    batch_accs_train.append(batch_acc)

  # Iterate over the testing data
  for x_batch, y_batch in test_dataset:
    y_pred_batch = log_reg(x_batch)
    batch_loss = log_loss(y_pred_batch, y_batch)
    batch_acc = accuracy(y_pred_batch, y_batch)
    # Keep track of batch-level testing performance
    batch_losses_test.append(batch_loss)
    batch_accs_test.append(batch_acc)

  # Keep track of epoch-level model performance
  train_loss, train_acc = tf.reduce_mean(batch_losses_train), tf.reduce_mean(batch_accs_train)
  test_loss, test_acc = tf.reduce_mean(batch_losses_test), tf.reduce_mean(batch_accs_test)
  train_losses.append(train_loss)
  train_accs.append(train_acc)
  test_losses.append(test_loss)
  test_accs.append(test_acc)
  if epoch % 20 == 0:
    print(f"Epoch: {epoch}, Training log loss: {train_loss:.3f}")

Epoch: 0, Training log loss: 0.661
Epoch: 20, Training log loss: 0.418
Epoch: 40, Training log loss: 0.269
Epoch: 60, Training log loss: 0.178
Epoch: 80, Training log loss: 0.137
Epoch: 100, Training log loss: 0.116
Epoch: 120, Training log loss: 0.106
Epoch: 140, Training log loss: 0.096
Epoch: 160, Training log loss: 0.094
Epoch: 180, Training log loss: 0.089

Darbības novērtējums

Novērojiet izmaiņas jūsu modeļa zudumu un precizitāti laika gaitā.

plt.plot(range(epochs), train_losses, label = "Training loss")
plt.plot(range(epochs), test_losses, label = "Testing loss")
plt.xlabel("Epoch")
plt.ylabel("Log loss")
plt.legend()
plt.title("Log loss vs training iterations");

plt.plot(range(epochs), train_accs, label = "Training accuracy")
plt.plot(range(epochs), test_accs, label = "Testing accuracy")
plt.xlabel("Epoch")
plt.ylabel("Accuracy (%)")
plt.legend()
plt.title("Accuracy vs training iterations");

print(f"Final training log loss: {train_losses[-1]:.3f}")
print(f"Final testing log Loss: {test_losses[-1]:.3f}")

Final training log loss: 0.089
Final testing log Loss: 0.077

print(f"Final training accuracy: {train_accs[-1]:.3f}")
print(f"Final testing accuracy: {test_accs[-1]:.3f}")

Final training accuracy: 0.968
Final testing accuracy: 0.979

Modelis demonstrē augstu precizitāti un zemu zudumu, kad runa ir par audzēju klasifikāciju apmācības datu kopumā, un arī vispārina labi uz neredzamiem testa datiem.

Šai problēmai FPR ir ļaundabīgo audzēju prognožu īpatsvars starp audzējiem, kas faktiski ir labdabīgi.

Aprēķiniet neskaidrību matricu, izmantojotsklearn.metrics.confusion_matrix, kas novērtē klasifikācijas precizitāti un izmanto matplotlib, lai rādītu matricu:

def show_confusion_matrix(y, y_classes, typ):
  # Compute the confusion matrix and normalize it
  plt.figure(figsize=(10,10))
  confusion = sk_metrics.confusion_matrix(y.numpy(), y_classes.numpy())
  confusion_normalized = confusion / confusion.sum(axis=1, keepdims=True)
  axis_labels = range(2)
  ax = sns.heatmap(
      confusion_normalized, xticklabels=axis_labels, yticklabels=axis_labels,
      cmap='Blues', annot=True, fmt='.4f', square=True)
  plt.title(f"Confusion matrix: {typ}")
  plt.ylabel("True label")
  plt.xlabel("Predicted label")

y_pred_train, y_pred_test = log_reg(x_train_norm, train=False), log_reg(x_test_norm, train=False)
train_classes, test_classes = predict_class(y_pred_train), predict_class(y_pred_test)

show_confusion_matrix(y_train, train_classes, 'Training')

show_confusion_matrix(y_test, test_classes, 'Testing')

Daudzos medicīnas testēšanas pētījumos, piemēram, vēža noteikšanā, augsts viltus pozitīvais rādītājs, lai nodrošinātu zemu viltus negatīvo rādītāju, ir pilnīgi pieņemams un faktiski mudināts, jo risks, ka pazaudē ļaundabīgo audzēju diagnozi (viltus negatīvu), ir daudz sliktāks nekā labdabīga audzēja kļūdaina klasifikācija kā ļaundabīga (viltus pozitīva).

Lai kontrolētu FPR un FNR, mēģiniet mainīt slieksnis hiperparametrs pirms klasificējot varbūtības prognozes. Zemāks slieksnis palielina modeļa vispārējās izredzes veikt ļaundabīgo audzēju klasifikāciju. Tas neizbēgami palielina skaitu viltus pozitīvo un FPR, bet arī palīdz samazināt skaitu viltus negatīvo un FNR.

Saglabājiet modeli

Sāciet, izveidojot eksporta moduli, kas ņem neapstrādātus datus un veic šādas darbības:

• Normalization
• Iespējamības prognoze
• Klases prognoze

class ExportModule(tf.Module):
  def __init__(self, model, norm_x, class_pred):
    # Initialize pre- and post-processing functions
    self.model = model
    self.norm_x = norm_x
    self.class_pred = class_pred

  @tf.function(input_signature=[tf.TensorSpec(shape=[None, None], dtype=tf.float32)])
  def __call__(self, x):
    # Run the `ExportModule` for new data points
    x = self.norm_x.norm(x)
    y = self.model(x, train=False)
    y = self.class_pred(y)
    return y

log_reg_export = ExportModule(model=log_reg,
                              norm_x=norm_x,
                              class_pred=predict_class)

Ja vēlaties saglabāt modeli pašreizējā stāvoklī, varat to izdarīt, izmantojottf.saved_model.saveLai ielādētu saglabāto modeli un veiktu prognozes, izmantojiettf.saved_model.load function.

models = tempfile.mkdtemp()
save_path = os.path.join(models, 'log_reg_export')
tf.saved_model.save(log_reg_export, save_path)

INFO:tensorflow:Assets written to: /tmpfs/tmp/tmp9k_sar52/log_reg_export/assets
INFO:tensorflow:Assets written to: /tmpfs/tmp/tmp9k_sar52/log_reg_export/assets

log_reg_loaded = tf.saved_model.load(save_path)
test_preds = log_reg_loaded(x_test)
test_preds[:10].numpy()

array([1., 1., 1., 1., 0., 1., 1., 1., 1., 1.], dtype=float32)

Secinājums

Šajā piezīmju grāmatiņā tika ieviestas dažas metodes, lai risinātu loģistikas regresijas problēmu.

• TensorFlow Core API var izmantot, lai izveidotu mašīntulkošanas darba plūsmas ar augstu konfigurējamības līmeni
• Kļūdu rādītāju analīze ir lielisks veids, kā iegūt lielāku ieskatu par klasifikācijas modeļa veiktspēju, kas pārsniedz tā vispārējo precizitātes punktu.
• Overfitting ir vēl viena bieži sastopama problēma loģistikas regresijas modeļiem, lai gan šī apmācība nebija problēma.

Lai iegūtu vairāk piemēru par TensorFlow Core API izmantošanu, skatietceļvedisJa vēlaties uzzināt vairāk par datu augšupielādi un sagatavošanu, skatietAttēlu datu iekraušanavaiCSV datu iekraušana.

Sākotnēji publicēts parTensorFlowŠis raksts šeit parādās ar jaunu virsrakstu un ir licencēts saskaņā ar CC BY 4.0.