diff --git a/Bericht/Bilder/difference.png b/Bericht/Bilder/difference.png new file mode 100644 index 0000000000000000000000000000000000000000..bc7a27d0a9119f084cf28c5e3a15135b40772ef9 Binary files /dev/null and b/Bericht/Bilder/difference.png differ diff --git a/Bericht/Bilder/difference_phase_angles.png b/Bericht/Bilder/difference_phase_angles.png deleted file mode 100644 index f65221bcd6180470ea24caf81b069bdc59404612..0000000000000000000000000000000000000000 Binary files a/Bericht/Bilder/difference_phase_angles.png and /dev/null differ diff --git a/Bericht/Bilder/difference_phase_angles.xcf b/Bericht/Bilder/difference_phase_angles.xcf index 3be79efa1e409322850c7814b1a4716d6e9dce51..bafccc673acb8bf38a2defcd6c95572257b4bd18 100644 Binary files a/Bericht/Bilder/difference_phase_angles.xcf and b/Bericht/Bilder/difference_phase_angles.xcf differ diff --git a/Bericht/Bilder/results_1637.png b/Bericht/Bilder/results_1637.png index 073d072b64e1feb070702c6d86137cbb28dd4ae4..e4fbed96c5aa37023f3be965806ff4ee4cbb076c 100644 Binary files a/Bericht/Bilder/results_1637.png and b/Bericht/Bilder/results_1637.png differ diff --git a/Bericht/Bilder/results_1637.xcf b/Bericht/Bilder/results_1637.xcf index ccb5ff83844b4182d9aa6a2c946e25d4b51aa4fe..c813702fdfc4500ed0cc374e4996961a1b4c2966 100644 Binary files a/Bericht/Bilder/results_1637.xcf and b/Bericht/Bilder/results_1637.xcf differ diff --git a/Bericht/vtk/difference.png b/Bericht/vtk/difference.png index e9fe7b717f894ff7c700fa34ef32c75201dd8fe1..f77c7b9aaa81e730ca8515e99c0dab1ad7538298 100644 Binary files a/Bericht/vtk/difference.png and b/Bericht/vtk/difference.png differ diff --git a/Bericht/vtk/result_angles.vtk b/Bericht/vtk/result_angles.vtk index 1afb9ea3df1e42896452b336d8f2fcf188c43ed7..f0c5312a51d8a7645bef29873bb3f05a153e0734 100644 Binary files a/Bericht/vtk/result_angles.vtk and b/Bericht/vtk/result_angles.vtk differ diff --git a/Bericht/vtk/stress_DAMASK.png b/Bericht/vtk/stress_DAMASK.png new file mode 100644 index 0000000000000000000000000000000000000000..d59701ab27c727f451d03945ef639c438c986ac9 Binary files /dev/null and b/Bericht/vtk/stress_DAMASK.png differ diff --git a/UNet/Auswertung_64.py b/UNet/Auswertung_64.py index 03d0e11e351f907f0ba88aef208c59e8a3fc0b29..d184793b5573738ed421cf4e5543cf81f493bd40 100644 --- a/UNet/Auswertung_64.py +++ b/UNet/Auswertung_64.py @@ -1,9 +1,9 @@ import torch import numpy as np -import UNet_V16 as UNet +import torch.nn as nn +import UNet_V14 as UNet import copy - def rescale(output, normalization): output_rescale = output.reshape(output.shape[2],output.shape[3],output.shape[4]) if normalization is not None: @@ -15,22 +15,21 @@ def rescale(output, normalization): output_rescale += min_label return output_rescale -def dataset_evaluation( normalization, model, dataset, threshold = 0.05): +def dataset_evaluation( normalization, model, dataloader, threshold = 0.05): model.eval() - mean_error = np.empty(len(dataset)) - max_error = np.empty(len(dataset)) - correct_per = np.empty(len(dataset)) #percentage of voxel that are guessed corrected, according to threshold - mean_deviation_abs = np.empty(len(dataset)) #absolute mean deviation between prediction and label per RVE - mean_deviation_per = np.empty(len(dataset)) #percentile mean deviation between prediction and label per RVE - - for index in range(len(dataset)): - input, output = dataset[index] + mean_error = [] + max_error = [] + correct_per = []#percentage of voxel that are guessed corrected, according to threshold + mean_deviation_abs = [] #absolute mean deviation between prediction and label per RVE + mean_deviation_per = [] #percentile mean deviation between prediction and label per RVE + + for batch in dataloader: + input, output = batch input = copy.copy(input) output = copy.copy(output) input = torch.unsqueeze(input,0) output = torch.unsqueeze(output,0) - xb = UNet.to_device(input, device) - prediction = model(xb) + prediction = model(input) input = input.detach().numpy() prediction = prediction.cpu().detach().numpy() output = output.detach().numpy() @@ -38,12 +37,12 @@ def dataset_evaluation( normalization, model, dataset, threshold = 0.05): output = rescale(output, normalization) error = (abs(output - prediction)/output) right_predic = (error < threshold).sum() - mean_error[index] = error.mean()*100. - max_error[index] = error.max()*100. - mean_deviation_abs[index] = prediction.mean() - output.mean() - mean_deviation_per[index] = (prediction.mean() - output.mean())/output.mean() + mean_error.append(error.mean()*100.) + max_error.append(error.max()*100.) + mean_deviation_abs.append(prediction.mean() - output.mean()) + mean_deviation_per.append((prediction.mean() - output.mean())/output.mean()) - correct_per[index] = (right_predic/error.size)*100. + correct_per.append((right_predic/error.size)*100.) return [mean_error, max_error, correct_per, mean_deviation_abs,mean_deviation_per] def best_sample_id(result): @@ -109,7 +108,7 @@ def export_vtk(error, grains, stress, label,path): if __name__ == '__main__': export_path = '/home/yk138599/Hiwi/damask3/UNet/output/result_14' - Training_data = torch.load(f'/home/yk138599/Hiwi/damask3/UNet/Trainingsdata/TD_norm_64_angles.pt.pt') + Training_data = torch.load(f'/home/yk138599/Hiwi/damask3/UNet/Trainingsdata/TD_norm_64_angles.pt') #Training_data = torch.load(f'/content/drive/MyDrive/Bachlorarbeit/Input/TD_norm_32_phase.pt') normalization = np.load(f'/home/yk138599/Hiwi/damask3/UNet/Trainingsdata/Norm_min_max_64_angles.npy', allow_pickle=True) @@ -117,8 +116,10 @@ if __name__ == '__main__': model = UNet.UNet() device = UNet.get_default_device() model = UNet.to_device(model.double(), device) - + dataloader = UNet.Create_Dataloader(f'/home/yk138599/Hiwi/damask3/UNet/Trainingsdata/TD_norm_64_angles.pt',batch_size=1) + dataloader = UNet.DeviceDataLoader(dataloader,device) model.load_state_dict(torch.load(f'/home/yk138599/Hiwi/damask3/UNet/output/V14/Unet_dict_V14.pth',map_location=torch.device('cuda'))) + result= dataset_evaluation( normalization = normalization, model = model, dataset = copy.copy(Training_data), threshold = 0.05) print(f'\t mean error over whole set: {result[0].mean():.4}%') print(f'\t max error average: {result[1].mean():.4}% and maximum {result[1].max():.4}%') diff --git a/UNet/visualize_vtk.ipynb b/UNet/visualize_vtk.ipynb index 92f7e731d46a08773c842a8708ca44136ffdabd0..708cbf71b122d020eaa813493d1ab4f54a0917a4 100644 --- a/UNet/visualize_vtk.ipynb +++ b/UNet/visualize_vtk.ipynb @@ -2,17 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", + "import matplotlib\n", "import numpy as np\n", "import pyvista as pv\n", "from matplotlib.colors import ListedColormap\n", + "from matplotlib.pyplot import figure\n", + "from matplotlib import colors\n", "import torch\n", "import copy\n", - "import UNet_V15 as UNet" + "import UNet_V16 as UNet" ] }, { @@ -103,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -112,21 +115,21 @@ "text": [ "no GPU found\n", "sample number: 1288\n", - "Maximum error is : 84.86 %\n", - "average error is : 9.575 %\n", - "77.27% of voxels have a diviation less than 15.0%\n" + "Maximum error is : 124.2 %\n", + "average error is : 9.365 %\n", + "78.4% of voxels have a diviation less than 15.0%\n" ] } ], "source": [ "path_to_UNET = 'F:/RWTH/HiWi_IEHK/DAMASK3'\n", - "export_path = 'F:/RWTH/HiWi_IEHK/DAMASK3/Bericht/vtk/result_phase'\n", + "export_path = 'F:/RWTH/HiWi_IEHK/DAMASK3/Bericht/vtk/result_angles'\n", "UNet = UNet\n", - "Training_data_32 = torch.load(f'{path_to_UNET}/UNet/Input/TD_norm_32_phase.pt')\n", + "Training_data_32 = torch.load(f'{path_to_UNET}/UNet/Input/TD_norm_32_angles.pt')\n", "normalization_32 = np.load(f'{path_to_UNET}/UNet/Input/Norm_min_max_32_phase.npy', allow_pickle=True)\n", "grain_data_32 = torch.load(f'{path_to_UNET}/UNet/Input/TD_norm_32_angles.pt')\n", "model = UNet.UNet()\n", - "model.load_state_dict(torch.load(f'{path_to_UNET}/UNet/output/V15/Unet_dict_V15.pth',map_location=torch.device('cpu')))\n", + "model.load_state_dict(torch.load(f'{path_to_UNET}/UNet/output/V16/Unet_dict_V16.pth',map_location=torch.device('cpu')))\n", "device = UNet.get_default_device()\n", "model = UNet.to_device(model.double(), device)\n", "\n", @@ -207,7 +210,7 @@ "\n", "p = pv.Plotter(off_screen=True)\n", "sargs = dict(\n", - " title='Stress (GPa)',\n", + " title='Stress U-Net (GPa)',\n", " n_labels=2,\n", ")\n", "p.add_mesh(slice,scalars=\"stress\",scalar_bar_args=sargs,name='Stress (GPa)')\n", @@ -217,43 +220,101 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%%capture\n", + "p = pv.Plotter(off_screen=True)\n", + "sargs = dict(\n", + " title='Stress DAMASK (GPa)',\n", + " n_labels=2,\n", + ")\n", + "p.add_mesh(slice,scalars=\"label\",scalar_bar_args=sargs,name='Stress DAMASK (GPa)')\n", + "p.view_zy()\n", + "p.screenshot('F:/RWTH/HiWi_IEHK/DAMASK3/Bericht/vtk/stress_DAMASK.png',transparent_background=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\CHRIST~1\\AppData\\Local\\Temp/ipykernel_16636/1273089677.py:30: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"transparent_background\" which is no longer supported as of 3.3 and will become an error in 3.6\n", + " plt.savefig('F:/RWTH/HiWi_IEHK/DAMASK3/Bericht/vtk/difference.png',transparent_background=True)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 864x864 with 2 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", "grid_angles= pv.read('F:/RWTH/HiWi_IEHK/DAMASK3/Bericht/vtk/result_angles.vtk')\n", "grid_phase = pv.read('F:/RWTH/HiWi_IEHK/DAMASK3/Bericht/vtk/result_phase.vtk')\n", - "difference = abs((grid_angles['stress'] - grid_phase['stress'])/(grid_angles['stress'])) \n", + "divnorm=colors.TwoSlopeNorm(vmin=-0.15, vcenter=0., vmax=0.15)\n", + "difference =(grid_angles['error'] - grid_phase['error'])\n", "grid = pv.UniformGrid()\n", "grid.dimensions =(33,33,33)\n", "grid.spacing = (1,1,1)\n", "grid.cell_data[\"difference\"] = difference.flatten(order = \"F\")\n", "slice= grid.slice()\n", + "#data = slice['difference'].reshape(32,32)\n", + "#annotations_difference = {\n", + "# 0: '0%'\n", + "#}\n", "\n", - "\n", - "\n", - "p = pv.Plotter(off_screen=True)\n", - "sargs_difference= dict(\n", - " title='Difference',\n", - " n_labels = 3\n", - " )\n", + "#p = pv.Plotter(off_screen=False)\n", + "#sargs_difference= dict(\n", + "# title='Difference',\n", + "# n_labels = 2\n", + "# )\n", "#grid.plot(scalars=\"error\",notebook=False,cmap=colormap_error)\n", - "p.add_mesh(slice,scalars=\"difference\",scalar_bar_args = sargs_difference)\n", - "p.view_zy()\n", - "p.screenshot('F:/RWTH/HiWi_IEHK/DAMASK3/Bericht/vtk/difference.png',transparent_background=True)\n" + "#p.add_mesh(slice,scalars=\"difference\",scalar_bar_args = sargs_difference, annotations=annotations_difference,cmap='coolwarm', norm=divnorm)\n", + "plt.figure(figsize=(12,12))\n", + "data = slice['difference'].reshape(32,32)\n", + "data = np.flip(data,1)\n", + "data = np.rot90(data,1)\n", + "plt.imshow(data,norm=divnorm,cmap='coolwarm',origin='lower')\n", + "#plt.tick_params(axis=’x’, which=’both’, bottom=False, top=False, labelbottom=False)\n", + "plt.colorbar(orientation=\"horizontal\")\n", + "#plt.show()\n", + "plt.savefig('F:/RWTH/HiWi_IEHK/DAMASK3/Bericht/vtk/difference.png',transparent_background=True)\n", + "#p.screenshot('F:/RWTH/HiWi_IEHK/DAMASK3/Bericht/vtk/difference.png',transparent_background=True)\n" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 35, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "IndexError", + "evalue": "too many indices for array: array is 1-dimensional, but 3 were indexed", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mC:\\Users\\CHRIST~1\\AppData\\Local\\Temp/ipykernel_16636/473156033.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mslice\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mgrid\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'difference'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mIndexError\u001b[0m: too many indices for array: array is 1-dimensional, but 3 were indexed" + ] + } + ], "source": [ - "Training_data_phase = torch.load(f'{path_to_UNET}/UNet/Input/TD_norm_32_phase.pt')\n", - "Training_data_angles = torch.load(f'{path_to_UNET}/UNet/Input/TD_norm_32_angles.pt')\n", - "\n", - "#max(grid_phase['error'] - grid_angles['error'])" + "slice == grid['difference'][0,:,:]" ] }, {