arxivi ichidagi papkani bitta papkaga chiqaring

HTML kodi:

<!DOCTYPE html>
<html>
<head>
<title>fonts bilan ishlash</title>
<link rel="stylesheet" type="text/css" href="css/style.css">
<link rel="stylesheet" type="text/css" href="fonts/font-awesome-4.7.0/css/font-awesome.css">
</head>
<body>
<div id="sayt">
<h1>Python HTML CSS darslari</h1>
<h2><i class="fa fa-camera"></i> Fotosuratlar</h2>
<h3><i class="fa fa-cloud-upload"></i> Malumotlarni yuklash</h3>
</div>
</body>
</html>

css kodi:


*{margin:0; padding: 0;}
@font-face
{
font-family: 'Montserrat-Light';
src : url("../fonts/Montserrat-Light.ttf") format('truetype');
}
#sayt
{
width: 1000px;
height: 500px;
border: 1px solid black;
margin: 20px auto;
}
#sayt h1
{
font-family: times new roman;
}
#sayt h2:hover
{
background-color: orange;
font-size: 25px;
}

#Dars 17 #HTML #CSS #Bootstrap
#Mavzu: Bootstrap kirish
#Admin: @JASUR_6355
#Kanal: @Python_videodarslar🧑🏻‍💻

HTML kodi:

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Bootstrap bilan ishlash</title>
<link rel="stylesheet" type="text/css" href="css/style.css">
<link rel="stylesheet" type="text/css" href="css/bootstrap.css">
<script type="text/javascript" src="js/jquery.js"></script>
<script type="text/javascript" src="js/bootstrap.js"></script>

</head>
<body>
<div class="container">
<div class="row">
<div class="col-5 chiziq">

</div>
<div class="col-2 chiziq">

</div>
<div class="col-2 chiziq">

</div>
<div class="col chiziq">

</div>
</div>
</div>
</body>
</html>

CSS kod:

.chiziq
{
border: 1px solid black;
height: 150px;
}

js va css papkalar bitta yerda turish kerak, Bootstrap kodlari ham ichida, omad👍🏻

namuna,misol, model
#vocab #tech

bajarib bo'lmaydigan, amalga oshirib bo'lmaydigan
#vocab #tech

ishonchli kuch, ishongan tog'
#vocab #tech

A neural network is just a slightly more advanced implementation of machine learning and we call that deep learning

#note

Start with the imports. Here, you are importing TensorFlow and calling it tf for convention and ease of use. The framework you will use to build a neural network as a sequence of layers is called keras and is contained within tensorflow, so you can access it using tf.keras.

You then import a library called numpy which helps to represent data as arrays easily and to optimize numerical operations.

import tensorflow as tf
import numpy as np

Before creating a neural network you will generate the data that you will be working with. In this case, you are taking 6 X's and 6 Y's. You can see that the relationship between these is y=2x-1, so where x=-1, y=-3 etc.

The standard way of declaring model inputs and outputs is to use numpy, a Python library that provides lots of array type data structures. You can specify these values by building numpy arrays with np.array(). Later in this course, you will learn how to use built-in TensorFlow functions to work with inputs.

# Declare model inputs and outputs for training
xs = np.array([-1.0,  0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

Define and Compile the Neural Network
Next, you will create the simplest possible neural network. It has 1 layer with 1 neuron. You will build this model using Keras' Sequential class which allows you to define the network as a sequence of layers. You can use a single Dense layer to build this simple network.

It is good practice to define the expected shape of the input to the model. In this case, you see that each element in xs is a scalar, which you can also treat as a 1-dimensional vector. You can define this shape through the tf.keras.Input() object and its shape parameter as shown below. Take note that this is not a layer so even if there are two lines of code inside Sequential below, this is still a one-layer model.

# Build a simple Sequential model
model = tf.keras.Sequential([

    # Define the input shape
    tf.keras.Input(shape=(1,)),

    # Add a Dense layer
    tf.keras.layers.Dense(units=1)
    ])

The process of training the neural network, where it 'learns' the relationship between the x's and y's is in the model.fit() call. This is where it will go through the loop we spoke about above: making a guess, measuring how good or bad it is (aka the loss), using the optimizer to make another guess etc. It will do it for the number of epochs you specify. When you run this code, you'll see the loss on the right hand side.

# Train the model

model.fit(xs, ys, epochs=500)

Recognition-Driven Fine-Tuning: Fine-tune an existing low-light enhancement model to better preserve features useful for recognition.
Adaptive Pre-processing: Develop a small, adaptive module that pre-processes low-light images before feeding them to a standard face recognition model.

we are gonna build "Adaptive Pre-Processing" module

I. The Core Idea: Recognition-Focused Pre-processing

Instead of trying to enhance the entire low-light image for general visual appeal, I'll create a small neural network that intelligently transforms the low-light input specifically to make it easier for a face recognition model to work. Think of it as a "low-light image translator" for face recognition.