Sponsorisé
Connectez-vous pour masquer les pubs
L IA, elle est pas un peu surcoté ?
Non, tu es caca détruire
[Vagin] La bible des plus belles femmes https://onche.org/topic/8[...]-beaux-vaginopodes-part-1
C'est pas du tout surcoté , tu as pas vu la transformation des LLM (CHATGPT ,gemini,claude) en très peu de temps?
From gagagouga à avoir 20 à l'oral de l'X en maths en 3-4 ans
From gagagouga à avoir 20 à l'oral de l'X en maths en 3-4 ans
C'est pas du tout surcoté , tu as pas vu la transformation des LLM (CHATGPT ,gemini,claude) en très peu de temps?
From gagagouga à avoir 20 à l'oral de l'X en maths en 3-4 ans
From gagagouga à avoir 20 à l'oral de l'X en maths en 3-4 ans
Il a aussi conseillé un mec de se soigner avec du cyanure
Un chatbot random de merde qui déconne = ia surcoté
Sponsorisé
Connectez-vous pour masquer les pubsDans combien d'années, je pourrais avoir mes films sur mesure en local ?
[Vagin] La bible des plus belles femmes https://onche.org/topic/8[...]-beaux-vaginopodes-part-1
Non mais je crois on s'est pas compris
Qu'on soit clair, IA est un avancement technologique de ouf
Mais je parle du commun des mortels qui pense que l ia va nous remplacer surtout et partout, qui pense que l'IA peut remplacer Rimbaud ou Proust
Qu'on soit clair, IA est un avancement technologique de ouf
Mais je parle du commun des mortels qui pense que l ia va nous remplacer surtout et partout, qui pense que l'IA peut remplacer Rimbaud ou Proust
Le coeur de Unet pour l'imagerie :
import torch
import torch.nn as nn
def double_conv(in_channels, out_channels):
"""Bloc de deux convolutions successives avec BatchNorm et ReLU"""
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
class UNet(nn.Module):
def __init__(self, n_class):
super(UNet, self).__init__()
# Partie Descendante (Encoder)
self.dconv_down1 = double_conv(3, 64)
self.dconv_down2 = double_conv(64, 128)
self.dconv_down3 = double_conv(128, 256)
self.dconv_down4 = double_conv(256, 512)
self.maxpool = nn.MaxPool2d(2)
self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
# Partie Ascendante (Decoder)
self.dconv_up3 = double_conv(256 + 512, 256)
self.dconv_up2 = double_conv(128 + 256, 128)
self.dconv_up1 = double_conv(64 + 128, 64)
self.conv_last = nn.Conv2d(64, n_class, kernel_size=1)
def forward(self, x):
# Encoder
conv1 = self.dconv_down1(x)
x = self.maxpool(conv1)
conv2 = self.dconv_down2(x)
x = self.maxpool(conv2)
conv3 = self.dconv_down3(x)
x = self.maxpool(conv3)
x = self.dconv_down4(x)
# Decoder + Skip Connections
x = self.upsample(x)
x = torch.cat([x, conv3], dim=1) # Concaténation
x = self.dconv_up3(x)
x = self.upsample(x)
x = torch.cat([x, conv2], dim=1)
x = self.dconv_up2(x)
x = self.upsample(x)
x = torch.cat([x, conv1], dim=1)
x = self.dconv_up1(x)
out = self.conv_last(x)
return out
import torch
import torch.nn as nn
def double_conv(in_channels, out_channels):
"""Bloc de deux convolutions successives avec BatchNorm et ReLU"""
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
class UNet(nn.Module):
def __init__(self, n_class):
super(UNet, self).__init__()
# Partie Descendante (Encoder)
self.dconv_down1 = double_conv(3, 64)
self.dconv_down2 = double_conv(64, 128)
self.dconv_down3 = double_conv(128, 256)
self.dconv_down4 = double_conv(256, 512)
self.maxpool = nn.MaxPool2d(2)
self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
# Partie Ascendante (Decoder)
self.dconv_up3 = double_conv(256 + 512, 256)
self.dconv_up2 = double_conv(128 + 256, 128)
self.dconv_up1 = double_conv(64 + 128, 64)
self.conv_last = nn.Conv2d(64, n_class, kernel_size=1)
def forward(self, x):
# Encoder
conv1 = self.dconv_down1(x)
x = self.maxpool(conv1)
conv2 = self.dconv_down2(x)
x = self.maxpool(conv2)
conv3 = self.dconv_down3(x)
x = self.maxpool(conv3)
x = self.dconv_down4(x)
# Decoder + Skip Connections
x = self.upsample(x)
x = torch.cat([x, conv3], dim=1) # Concaténation
x = self.dconv_up3(x)
x = self.upsample(x)
x = torch.cat([x, conv2], dim=1)
x = self.dconv_up2(x)
x = self.upsample(x)
x = torch.cat([x, conv1], dim=1)
x = self.dconv_up1(x)
out = self.conv_last(x)
return out
Le coeur de Unet pour l'imagerie :
import torch
import torch.nn as nn
def double_conv(in_channels, out_channels):
"""Bloc de deux convolutions successives avec BatchNorm et ReLU"""
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
class UNet(nn.Module):
def __init__(self, n_class):
super(UNet, self).__init__()
# Partie Descendante (Encoder)
self.dconv_down1 = double_conv(3, 64)
self.dconv_down2 = double_conv(64, 128)
self.dconv_down3 = double_conv(128, 256)
self.dconv_down4 = double_conv(256, 512)
self.maxpool = nn.MaxPool2d(2)
self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
# Partie Ascendante (Decoder)
self.dconv_up3 = double_conv(256 + 512, 256)
self.dconv_up2 = double_conv(128 + 256, 128)
self.dconv_up1 = double_conv(64 + 128, 64)
self.conv_last = nn.Conv2d(64, n_class, kernel_size=1)
def forward(self, x):
# Encoder
conv1 = self.dconv_down1(x)
x = self.maxpool(conv1)
conv2 = self.dconv_down2(x)
x = self.maxpool(conv2)
conv3 = self.dconv_down3(x)
x = self.maxpool(conv3)
x = self.dconv_down4(x)
# Decoder + Skip Connections
x = self.upsample(x)
x = torch.cat([x, conv3], dim=1) # Concaténation
x = self.dconv_up3(x)
x = self.upsample(x)
x = torch.cat([x, conv2], dim=1)
x = self.dconv_up2(x)
x = self.upsample(x)
x = torch.cat([x, conv1], dim=1)
x = self.dconv_up1(x)
out = self.conv_last(x)
return out
import torch
import torch.nn as nn
def double_conv(in_channels, out_channels):
"""Bloc de deux convolutions successives avec BatchNorm et ReLU"""
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
class UNet(nn.Module):
def __init__(self, n_class):
super(UNet, self).__init__()
# Partie Descendante (Encoder)
self.dconv_down1 = double_conv(3, 64)
self.dconv_down2 = double_conv(64, 128)
self.dconv_down3 = double_conv(128, 256)
self.dconv_down4 = double_conv(256, 512)
self.maxpool = nn.MaxPool2d(2)
self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
# Partie Ascendante (Decoder)
self.dconv_up3 = double_conv(256 + 512, 256)
self.dconv_up2 = double_conv(128 + 256, 128)
self.dconv_up1 = double_conv(64 + 128, 64)
self.conv_last = nn.Conv2d(64, n_class, kernel_size=1)
def forward(self, x):
# Encoder
conv1 = self.dconv_down1(x)
x = self.maxpool(conv1)
conv2 = self.dconv_down2(x)
x = self.maxpool(conv2)
conv3 = self.dconv_down3(x)
x = self.maxpool(conv3)
x = self.dconv_down4(x)
# Decoder + Skip Connections
x = self.upsample(x)
x = torch.cat([x, conv3], dim=1) # Concaténation
x = self.dconv_up3(x)
x = self.upsample(x)
x = torch.cat([x, conv2], dim=1)
x = self.dconv_up2(x)
x = self.upsample(x)
x = torch.cat([x, conv1], dim=1)
x = self.dconv_up1(x)
out = self.conv_last(x)
return out
Bah c'est des maths+ info
T’as cru que ça allait être des incantations ? 'Ô dieu de l’IA, par le pouvoir du silicium, segmente-moi ce foie malade !"
T’as cru que ça allait être des incantations ? 'Ô dieu de l’IA, par le pouvoir du silicium, segmente-moi ce foie malade !"
l'un empêche pas l'autre
¡Esta serpiente marina MATÓ a un Celestino! https://streamable.com/fmjgjb
